shift count too large

OP #1235754
Lesenswert?

1
    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.
#1235765
Lesenswert?

Johannes Hofmann wrote:
>
1
    if(Pixel_Cell & (1 << BIT4)) { MYPORT |= (1 << PIN4); } else {
2
> 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...
Gast #1235767
Lesenswert?

>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
OP #1235795
Lesenswert?

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.
1
#include <msp430x21x2.h>
2

3
void Read_Cell(unsigned int Pixel_Cell){
4
    
5

6
    if(Pixel_Cell & (1 << MYBIT0)) { P1OUT |= (1 << MYPIN0); } else { P1OUT &= ~(1 << MYPIN0); }
7
    if(Pixel_Cell & (1 << MYBIT1)) { P1OUT |= (1 << MYPIN1); } else { P1OUT &= ~(1 << MYPIN1); }
8
    if(Pixel_Cell & (1 << MYBIT2)) { P1OUT |= (1 << MYPIN2); } else { P1OUT &= ~(1 << MYPIN2); }
9
    if(Pixel_Cell & (1 << MYBIT3)) { P1OUT |= (1 << MYPIN3); } else { P1OUT &= ~(1 << MYPIN3); }
10
    if(Pixel_Cell & (1 << MYBIT4)) { P1OUT |= (1 << MYPIN4); } else { P1OUT &= ~(1 << MYPIN4); }
11
}
12

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

28

29
  }
30
  //__bis_SR_register(CPUOFF);                // Enter LPM0 (Low Power Mode 0)
31
  //return 0;
32
}
Gast #1235812
Lesenswert?

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
OP #1235838
Lesenswert?

In der Headerdatei sieht es folgendermaßen aus:
1
#define BIT0                (0x0001)
2
#define BIT1                (0x0002)
3
#define BIT2                (0x0004)
4
#define BIT3                (0x0008)
5
#define BIT4                (0x0010)
6

7
#define P1IN_               (0x0020)  /* Port 1 Input */
8
READ_ONLY DEFC( P1IN           , P1IN_)
9
#define P1OUT_              (0x0021)  /* Port 1 Output */
10
DEFC(   P1OUT             , P1OUT_)
11
#define P1DIR_              (0x0022)  /* Port 1 Direction */
12
DEFC(   P1DIR             , P1DIR_)
13
#define P1IFG_              (0x0023)  /* Port 1 Interrupt Flag */
14
DEFC(   P1IFG             , P1IFG_)
15
#define P1IES_              (0x0024)  /* Port 1 Interrupt Edge Select */
16
DEFC(   P1IES             , P1IES_)
17
#define P1IE_               (0x0025)  /* Port 1 Interrupt Enable */
18
DEFC(   P1IE              , P1IE_)
19
#define P1SEL_              (0x0026)  /* Port 1 Selection */
20
DEFC(   P1SEL             , P1SEL_)
21
#define P1SEL2_             (0x0041)  /* Port 1 Selection 2 */
22
DEFC(   P1SEL2            , P1SEL2_)
23
#define P1REN_              (0x0027)  /* Port 1 Resistor Enable */
24
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:
1
        if(Pixel_Cell & (1 << BIT0)) { P1OUT |= (1 << BIT0); } else { P1OUT &= ~(1 << BIT0); }
2
    if(Pixel_Cell & (1 << BIT1)) { P1OUT |= (1 << BIT1); } else { P1OUT &= ~(1 << BIT1); }
3
    if(Pixel_Cell & (1 << BIT2)) { P1OUT |= (1 << BIT2); } else { P1OUT &= ~(1 << BIT2); }
4
    if(Pixel_Cell & (1 << BIT3)) { P1OUT |= (1 << BIT3); } else { P1OUT &= ~(1 << BIT3); }
5
    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?
Gast #1235865
Lesenswert?

>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
Gast #1235913
Lesenswert?

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.
Moderator (Firma: Titel) Persönliche Seite #1235978
Lesenswert?

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

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:
1
void Read_Cell(unsigned int Pixel_Cell){
2
    P1OUT = (P1OUT&0xE0) | (Pixel_Cell&0x1F);
3
}

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren