shift count too large

[Johannes (menschenskind)]

    if(Pixel_Cell & (1 << BIT4)) { MYPORT |= (1 << PIN4); } else { MYPORT &= ~(1 << PIN4); }

Dabei kommt die Fehlermeldung "shift count too large".
Pixel_Cell hab ich als unsigned int deklariert.
Ein Problem des Datenformats kann es ja nicht sein, oder?

Bit4 und Pin4 sind als '4' definiert.
Ein Byte läuft ja von 0 bis 3 und 4 ist da also drüber, das ist klar, 
aber mit int habe ich ja schon ein paar mehr Bits zur Verfügung, deshalb 
ist das Ganze recht rätselhaft.

[Johannes M. (johnny-m)]

Johannes Hofmann wrote:
>

    if(Pixel_Cell & (1 << BIT4)) { MYPORT |= (1 << PIN4); } else {
> MYPORT &= ~(1 << PIN4); }

>
> Dabei kommt die Fehlermeldung "shift count too large".
> Pixel_Cell hab ich als unsigned int deklariert.
> Ein Problem des Datenformats kann es ja nicht sein, oder?
>
> Bit4 und Pin4 sind als '4' definiert.
Erstens solltest Du auf Groß- und Kleinschreibung achten, da es sich 
hier offensichtlich um C handelt. BIT4 ist etwas anderes als Bit4. 
Zweitens ist es ein gewaltiger Unterschied, ob etwas als '4' oder als 4 
definiert ist. '4' ist ein ASCII-Zeichen.

> Ein Byte läuft ja von 0 bis 3
Was für eine Plattform ist das bitteschön, auf der ein Byte nur 4 Bits 
hat?

Du solltest wirklich mal die Forenregeln beachten und im Betreff 
erzählen, um welches System es überhaupt geht...

[Oliver (Gast)]

>Ein Byte läuft ja von 0 bis 3
Die Bytes, die ich kenne, gehen von 0 bis 7.

>deshalb ist das Ganze recht rätselhaft.
Die eine Zeile, ohne Angabe, womit und wofür kompiliert wurde, hilft da 
nicht weiter.

Zeig den ganzen Code, mit allen Infos.

Oliver

[Johannes (menschenskind)]

Jo sorry, natürlich ist ein Byte ein wenig größer...
Und '4' hab ich auch nur geschrieben, um das etwas hervorzuheben.

Es geht um den uC MSP430 und ich benutze die IAR Workbench von ti.

Den Code mit MYPIN und MYBIT hab ich hier aus nem Thread übernommen.

#include <msp430x21x2.h>

void Read_Cell(unsigned int Pixel_Cell){
    

    if(Pixel_Cell & (1 << MYBIT0)) { P1OUT |= (1 << MYPIN0); } else { P1OUT &= ~(1 << MYPIN0); }
    if(Pixel_Cell & (1 << MYBIT1)) { P1OUT |= (1 << MYPIN1); } else { P1OUT &= ~(1 << MYPIN1); }
    if(Pixel_Cell & (1 << MYBIT2)) { P1OUT |= (1 << MYPIN2); } else { P1OUT &= ~(1 << MYPIN2); }
    if(Pixel_Cell & (1 << MYBIT3)) { P1OUT |= (1 << MYPIN3); } else { P1OUT &= ~(1 << MYPIN3); }
    if(Pixel_Cell & (1 << MYBIT4)) { P1OUT |= (1 << MYPIN4); } else { P1OUT &= ~(1 << MYPIN4); }
}

int main( void ){
  
  // Stop watchdog timer to prevent time out reset
  WDTCTL = WDTPW + WDTHOLD;
  
  while(1){
    P1DIR |= 0x5F;                            // Port1 als Output
    P1SEL |= 0x00;                            // Sets Mode of Port 0x00 corresponds to I/O functionality
    TA0CCR0 = 512 - 1;                        // PWM Period
    TA0CCTL1 = OUTMOD_7;                      // TA0CCR1 reset/set (toggle)
    TA0CCR1 = 384;                            // TA0CCR1 PWM duty cycle Tastverhältnis
    TA0CTL = TASSEL_2 + MC_1;                 
    
    Read_Cell(12);


  }
  //__bis_SR_register(CPUOFF);                // Enter LPM0 (Low Power Mode 0)
  //return 0;
}

[(prx) A. K. (prx)]

Kann der IAR das Ergebnis vom Präprozessor auswerfen? Wenn ja, dann 
schau da mal rein.

Andererseits kann ich mit irgendwie nicht vorstellen, dass in 
<msp430x21x2.h> die MYBITx/MYPINx definiert sind. Der Teil fehlt also 
weiterhin.

[Karl H. (kbuchegg)]

> Zeig den ganzen Code, mit allen Infos.
           ******

Wie sind MYPINx bzw. MYBITx definiert?

[Oliver (Gast)]

Hilfreich ist es auch, bei so etwas immer nur eine Anweisung pro Zeile 
zu haben, dann lassen sich Fehlermeldungen einfacher zuordnen. Wenn du 
wüsstest, über welchen der drei shifts der Compiler meckert, wäre die 
Lösung vermutlich einfach.

Oliver

[Stefan E. (sternst)]

Ich wette, dass die ganzen MYxxx bereits Masken sind und keine Nummern. 
Dann wäre nämlich MYBIT3 8 und MYBIT4 16, und letzteres wird dann vom 
Compiler für ein 16-Bit-int als ein zu großer shift-Operant angesehen.

[H.Joachim S. (crazyhorse)]

Das glaube ich auch :-)

[Johannes (menschenskind)]

In der Headerdatei sieht es folgendermaßen aus:

#define BIT0                (0x0001)
#define BIT1                (0x0002)
#define BIT2                (0x0004)
#define BIT3                (0x0008)
#define BIT4                (0x0010)

#define P1IN_               (0x0020)  /* Port 1 Input */
READ_ONLY DEFC( P1IN           , P1IN_)
#define P1OUT_              (0x0021)  /* Port 1 Output */
DEFC(   P1OUT             , P1OUT_)
#define P1DIR_              (0x0022)  /* Port 1 Direction */
DEFC(   P1DIR             , P1DIR_)
#define P1IFG_              (0x0023)  /* Port 1 Interrupt Flag */
DEFC(   P1IFG             , P1IFG_)
#define P1IES_              (0x0024)  /* Port 1 Interrupt Edge Select */
DEFC(   P1IES             , P1IES_)
#define P1IE_               (0x0025)  /* Port 1 Interrupt Enable */
DEFC(   P1IE              , P1IE_)
#define P1SEL_              (0x0026)  /* Port 1 Selection */
DEFC(   P1SEL             , P1SEL_)
#define P1SEL2_             (0x0041)  /* Port 1 Selection 2 */
DEFC(   P1SEL2            , P1SEL2_)
#define P1REN_              (0x0027)  /* Port 1 Resistor Enable */
DEFC(   P1REN             , P1REN_)

Das mit MYBIT0 usw. hab ich mal korrigiert, aber daran liegt es nicht, 
ich hatte das in einer Headerdatei schon richtig zugewiesen. Außerdem 
bezieht sich die Fehlermeldung auf was anderes, genau genommen ist es 
eine Warnmeldung.

Hier jetzt noch mal anders:

        if(Pixel_Cell & (1 << BIT0)) { P1OUT |= (1 << BIT0); } else { P1OUT &= ~(1 << BIT0); }
    if(Pixel_Cell & (1 << BIT1)) { P1OUT |= (1 << BIT1); } else { P1OUT &= ~(1 << BIT1); }
    if(Pixel_Cell & (1 << BIT2)) { P1OUT |= (1 << BIT2); } else { P1OUT &= ~(1 << BIT2); }
    if(Pixel_Cell & (1 << BIT3)) { P1OUT |= (1 << BIT3); } else { P1OUT &= ~(1 << BIT3); }
    if(Pixel_Cell & (1 << BIT4)) { P1OUT |= (1 << BIT4); } else { P1OUT &= ~(1 << BIT4); }

Dabei habe ich noch festgestellt, dass in der Headerdatei ja P1OUT_ 
steht, ich aber in meinem Code P1OUT verwende und es trotzdem 
funktioniert.
Was macht denn der Compiler aus diesem Unterstrich?

[(prx) A. K. (prx)]

Johannes Hofmann wrote:

> #define BIT4                (0x0010)

1<<16 = 65536. Entweder Maske verwenden und dann aber auf den Shift 
verzichten, oder statt Maske die Bitnummer verwenden.

Stefan, du hast die Wette gewonnen.

[Johannes (menschenskind)]

Ok, jetzt seh ich das auch endlich!
Jetzt wärs noch ganz lieb, wenn ihr mir diese Sache mit dem Unterstrich 
noch erklären könntet.

Danke

[Karl H. (kbuchegg)]

Welcher Unterstrich?

Offenbar gibt es 2 Makros.
Einmal P1OUT_ und einmal P1OUT

[Oliver (Gast)]

>Dabei habe ich noch festgestellt, dass in der Headerdatei ja P1OUT_
>steht, ich aber in meinem Code P1OUT verwende und es trotzdem
>funktioniert.

Obwohl da weiter oben ja "nur" ein Warnung kommt, wird der Code mit 
Sicherheit nicht funktionieren.

>Jetzt wärs noch ganz lieb, wenn ihr mir diese Sache mit dem Unterstrich
>noch erklären könntet.

Da gibt es nichts zu erklären, PIOUT und PIOUT_ sind zwei 
unterschiedliche Dinge. Was was ist, und was du wie benutzen musst, sagt 
dir der zugehörige Quellcode (oder die Doku) zum macro READ_ONLY DEFC(), 
der hier leider nirgends sichtbar ist.

Oliver

[D.B. (Gast)]

Bevor man eine API benutzt sollte man sich schon anschauen wie die 
funktioniert.
Unsachgemäße Nutzung merkt man nur mit Glück (wie oben) zur Compilezeit. 
1 << BIT0 kann zur Laufzeit ins Auge gehen wenn man das in n 
Datenrichtungsregister knüppelt.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

void Read_Cell(unsigned int Pixel_Cell){
    if(Pixel_Cell & (1 << MYBIT0)) { P1OUT |= (1 << MYPIN0); } else { P1OUT &= ~(1 << MYPIN0); }
    if(Pixel_Cell & (1 << MYBIT1)) { P1OUT |= (1 << MYPIN1); } else { P1OUT &= ~(1 << MYPIN1); }
    if(Pixel_Cell & (1 << MYBIT2)) { P1OUT |= (1 << MYPIN2); } else { P1OUT &= ~(1 << MYPIN2); }
    if(Pixel_Cell & (1 << MYBIT3)) { P1OUT |= (1 << MYPIN3); } else { P1OUT &= ~(1 << MYPIN3); }
    if(Pixel_Cell & (1 << MYBIT4)) { P1OUT |= (1 << MYPIN4); } else { P1OUT &= ~(1 << MYPIN4); }
}

Wenn dieser Code mit
MYBIT0..4 = MYPIN0..4 = BIT0..4 = 0..4
letztlich das tut, was du meinst, dass er tun soll, könntest du das 
Ganze signifikant abkürzen:

void Read_Cell(unsigned int Pixel_Cell){
    P1OUT = (P1OUT&0xE0) | (Pixel_Cell&0x1F);
}