Vad innebär "Too many initializers" som kompileringsfel?

[Magnus_K]

God kväll,

Ibland när jag deklarerar en global variabel och ger den direkt ett värde, så får jag kompileringsmeddelandet Too many initializers.

Mitt nuvarande exempel ser ut så här: bit slaveRUNNING = 1; och tar jag bort = 1 så kompilerar det fin fint.
Har inga problem att posta all kod men det börjar bli rätt mycket nu och ganska rörigt. Kan någon ge mig en hint vad jag ska leta efter så kan jag posta just den delen?

Själv tolkar jag meddelandet att någonstans i koden så har jag skapat en dubblet av min deklaration/initiering (eller vad det nu kallas när man anger värde direkt) men det har jag verkligen inte gjort.

[sodjan]

Får du även felet med en liten enkel testkod?
I så fall kan du posta en "reproducer" som visar felet.
Men det är väl bara att leta efter "slaveRUNNING" i koden...

[Micke_s]

Vad är bit för datatyp?

[Icecap]

Bit som datatyp är ju just en bit. Vid att ge den ett värde kommer samma byte som är värd för 8 bits att ha upp till 8 värden varför kompilern gnäller och anser att du borde nöja dig med en enda.

Och detta gäller vid bit som datatyp i alla lägen, det går såklart att lösa men det kräver en del struktur samt en definition på byte-nivå som man då ställer till rätt nivå.

Just sådana problem är orsaken till att jag aldrig predefinierar innehållet men istället sätter det under initieringen vid programstart, kopieringen ska ju göras ändå och då är det lika bra att den är under min kontroll från början.

[Nerre]

Men bit är väl ingen standariserad datatyp i C?

Är det nåt som är specifikt för en viss kompilator? Hur är typen definierad?

[svanted]

#include "stdbool.h"

typedef bool bit;

[datajompa]

Posta all kod, ditt exempel är troligen inte det som ger felmeddelandet, brukar vara något med arrays.

Har du kollat raden innan?

[Magnus_K]

Har tyvärr inte kunnat svara förrän nu.

bit i MikroC är just en bit, gissar det är precis samma som BOOL?
Vet inte på rak arm om det händer för andra typer än för just "bit" men det kan jag testa under kvällen och återkomma med.

Nedan är programmet och jag ni får gärna avstå med dryga kommentarer om hur det ser ut för jag är på randen till sammanbrott men ska göra ett försök till innan jag tar en liten paus.
VARNING: Svengelska!

Kod: Markera allt

/*******************************************************************************
*                           Master_clock project                               *
*                                                                              *
*   Interface          - Button, debounce and I/O setup                        *
*                      - Rotary switch, activate ADC and I/O setup             *
*                      - Display, activate USART and I/O setup                 *
*                                                                              *
*   Special functions  - Brown out trigger, set up timer, IoC and EEPROM com.  *
*                      - 1 Hz signal, set up counter and IoC                   *
*                                                                              *
*                                                                              *
*  1440min/dygn, 720min/12hr                                                   *
*  Update display in 125Hz (each 8ms), (625Hz timer flag)                      *
*  Button debounce counter at 250Hz, will fill up register in 4ms*8=32ms       *
*                                                                              *
*                                                                              *
* Grid 1 - RC0                                                                 *
* Grid 2 - RC1                                                                 *
* Grid 3 - RC2                                                                 *
* Grid 4 - RC4                                                                 *
* Grid 5 - RC5                                                                 *
*                                                                              *
* Display serial data - RB5                                                    *
* Display data clock - RB7                                                     *
* Display latch clock - RB6                                                    *
* Display Enable - RC6                                                         *
*                                                                              *
* Push Button - RB4                                                            *
* Rotary Switch - RC3 (AN7)                                                    *
* 1 Hz pulse - RC7                                                             *
* Grid sense - RA2 (INT)                                                       *
*                                                                              *
* Clock pulse North - RA4                                                      *
* Clock pulse South - RA5                                                      *
*                                                                              *
* TYPE                   BYTES           RANGE                                 *
* bit                    1–bit           0 or 1                                *
* sbit                   1–bit           0 or 1                                *
* (unsigned) char        1               0 .. 255                              *
* signed char            1               - 128 .. 127                          *
* (signed) short (int)   1               - 128 .. 127                          *
* unsigned short (int)   1               0 .. 255                              *
* (signed) int           2               -32768 .. 32767                       *
* unsigned (int)         2               0 .. 65535                            *
* (signed) long (int)    4               -2147483648 .. 2147483647             *
* unsigned long (int)    4               0 .. 4294967295                       *
*                                                                              *
*                                                                              *
*  TODO:                                                                       *
*        FLYTTA UT setSLAVE UR INTERRUPT                                       *
*        SKAPA BROWN OUT FUNKTION                                              *
*        SKAPA EEPROM SPARA/ÅTERKALLA FUNKTION                                 *
*                                                                              *
*                                                                              *
*                                                                              *
********************************************************************************/

char debounceCtr = 0;
char secCtr = 0;
char ADC_value = 0;
char D1, D2, D3, D4, DP;
bit pushButton_Status;
bit newPulse;
bit newTRANSFER;
bit setSLAVE;
bit pulseACTIVE;
bit slaveRUNNING = 1;
unsigned int timeCounter;
unsigned int analogTime;
unsigned int digitalTime;
unsigned int digitCounter = 0;
unsigned int analogCounter;

#define pushButton PORTB.B4
#define rotarySwitch PORTC.B3
#define secPulse PORTC.B7
#define HOURS timeCounter / 60
#define MINUTES timeCounter
#define EUSART_LATCH PORTB.B6
#define EUSART_DATALINE PORTB.B5
#define EUSART_DATACLK PORTB.B7
#define SLAVE_NORTH PORTA.B4
#define SLAVE_SOUTH PORTA.B5
#define NORTH 0
#define SOUTH 1


const char NUMBER[11] = {
      0b00000001,    //DP
      0b11000000,    //0
      0b11111001,    //1
      0b10100100,    //2
      0b10110000,    //3
      0b10011001,    //4
      0b10010010,    //5
      0b10000010,    //6
      0b11111000,    //7
      0b10000000,    //8
      0b10010000     //9
};

const char GRID[5] = {

      0b000010000,   // X0:00
      0b000001000,   // 0X:00
      0b000000100,   // 00X00
      0b000000010,   // 00:X0
      0b000000001    // 00:0X
};


//******************************************************************************
// Basic configuration of I/O:s, frequencies
//******************************************************************************
void BASIC_init() {

      //OSSCON = 0b00000000;         Set clock freq

      ANSEL = 0b10000000;               //AN7 enable (RC3)
      ANSELH = 0;
      
      ADCON0 = 0b00011101;              // ADC for CH7 on
      ADCON1 = 0b01010000;              // Fosc/16 conversion time

      PORTA = 0b00000000;
      PORTB = 0b00000000;
      PORTC = 0b00000000;
      TRISA = 0b00011000;
      TRISB = 0b00000000;
      TRISC = 0b00000100;
}


//******************************************************************************
// The EUSART is configured as synchronous master with highest possible baud
//******************************************************************************
void EUSART_init() {

      SPBRG = 0b00000000;             // Try baud rate SPBRG 0 for highest speed
      PIE1.TXIE = 0;                  // Interrupt is PIE1.TXIE, INTCON.GIE and INTCON.PEIE
      TXSTA.SYNC = 1;                 // SYNC bit (1) in TXSTA = sync operation
      TXSTA.CSRC = 1;                 // CSRC bit (1) in TXSTA = PIC master
      RCSTA.SREN = 0;
      RCSTA.CREN = 0;                 // SREN & CREN bit (0) in RCSTA = transmit mode
      RCSTA.SPEN = 1;                 // SPEN bit (1) in RCSTA = Enable EUSART
      BAUDCTL.SCKP = 0;               // Clock polarity - BAUDCTL.SCKP (0) is clock idle low, data trf on rising edge
}

//******************************************************************************
// The segmentCalc-function calculates which number that should be displayed
// on each segment. Also flips the colon once each second.
//******************************************************************************
void segmentCalc(void) {

     static bit DP_set;

     if(secPulse && !DP_set) {
     
          DP = NUMBER[0];
          DP_set = 1;
     }
     if(!secPulse && DP_set) {
     
          DP = 0;
          DP_set = 0;
     }

     D1 = HOURS / 10;
     D2 = HOURS - (D1 * 10);
     D3 = MINUTES / 10;
     D4 = MINUTES - (D3 * 10);
     
}

void sendPULSE(void) {

     if(!pulseACTIVE) {
        setSLAVE = 1;
     }

}


void main() {

     BASIC_init();
     EUSART_init();

     while(1) {                          //lägg till medans klockan stabil

              // On every incoming 1 Hz pulse the timeCounter will increment by
              // 1. 60 mins for 24 hrs gives a total of 1440 minutes.
              // Since the analog clock only display up to 12 hrs, 720 mins
              // needs to be subtracted from the counter when it exceedes that.
              if(secPulse && newPulse) {
                 secCtr++;
                 newPulse = 0;
              }
              if(!secPulse) {
                 newPulse = 1;
              }
              if(secCtr >= 60) {
                 secCtr = 0;
                 timeCounter++;
                 if(slaveRUNNING){
                    sendPULSE();
                 }
              }
              if(timeCounter >= 1440) {
                 timeCounter = 0;
              }
              if(timeCounter >= 720) {
                 analogTime = (timeCounter-720);
              } else {
                 analogTime = timeCounter;
              }

              segmentCalc();

              // When the segments has been updated from the ISR, newTRANSFER
              // will be true and new data transfered to the ext shift register.
              // The loop will halt during the transmission and transfer will be
              // stopped to not overrun the datatransfer when complete.
              if(newTRANSFER) {
              
                 short i;
                 i = digitCounter;
                 i++;
                 if(i >= 5) {
                    i = 0;
                 }
                 TXSTA.TXEN = 1;
                 switch (i) {
                 case 0:
                   TXREG = D1;
                   break;
                 case 1:
                   TXREG = D2;
                   break;
                 case 2:
                   TXREG = DP;
                   break;
                 case 3:
                   TXREG = D3;
                   break;
                 case 4:
                   TXREG = D4;
                   break;
                 default:
                   TXREG = 0;
                   break;
                 }
                 while(TXSTA.TRMT) {}
              }
              
              ADC_value = ADRESH;
              if(ADC_value > 200){                     //Set correct ADC_value
              
                 char i;
                 
                 if(pushButton_status) {

                    for(i = 0;i >= 255;i++) {
                        timeCounter++;
                    }
                 } 
                 else {
                   i = 0;
                 }
              }
              
              if((ADC_value < 200) && (ADC_value > 100)){                     //Set correct ADC_value
                 if(pushButton_status) {                           //Function to step the slave forward
                    sendPULSE();

                    analogCounter = analogTIME;
                 }
              }
              
              if(ADC_value < 100) {                               // Set correct ADC_value
                 if(pushButton_status && slaveRUNNING) {
                    if(analogTIME == analogCounter) {
                       slaveRUNNING = 1;
                    }
                    if(analogTIME != analogCounter) {
                       slaveRUNNING = 0;
                    }
                 }
                 
                 if(!slaveRUNNING) {
                    if(analogTIME != analogCounter) {
                       sendPULSE();
                    }
                    if(analogTIME == analogCounter) {
                       slaveRUNNING = 1;
                    }
                 
                 }
              }
     }

}


//******************************************************************************
// Low priority interrupt that handles debounce of  the one and only pushbutton
// Every 4ms (250Hz) the status of the button is shifted into the debounce
// counter. If 8 high/low signals detected the button will be classified as
// 'pushed' or 'released'. Total max debounce time = 32ms
// It also initiates the ADC for the rotary switch.
//******************************************************************************
void interrupt_low(void) {                       // debounce interrupt

     if (PIR1.TMR1IF) {

         PIR1.TMR1IF = 0;                        // Reset interruptflag
         debounceCtr <<= 1;                      // Shift all bits one step up
         debounceCtr |= pushButton;              // OR:a in värdet från RB4

         if (debounceCtr == 0xff) {              // Om byte:n endast innehåller 1:or så sätt status till 1
             pushButton_Status = 1;
         }

         else if (debounceCtr == 0x00) {         // Om byte:n endast innehåller 0:or så sätt status till 0
                  pushButton_Status = 0;
         }
         
         ADCON0.ADON = 1;
         
            if(setSLAVE) {
         
         
               static bit nextPulse;
               static bit i;
               pulseACTIVE = 1;
         
               if(nextPulse == NORTH) {

                  SLAVE_SOUTH = 0;
                  TRISA.B5 = 1;
                  TRISA.B4 = 0;
                  SLAVE_NORTH = 1;
                  for(i=0;i>=25;i++) {
                      SLAVE_NORTH = 0;
                      TRISA.B4 = 1;
                      nextPulse = SOUTH;
                      i = 0;
                      pulseACTIVE = 0;
                  }
               }
            
               if(nextPulse == SOUTH) {
            
                  SLAVE_NORTH = 0;
                  TRISA.B4 = 1;
                  TRISA.B5 = 0;
                  SLAVE_SOUTH = 1;
                  for(i=0;i>=25;i++) {
                      SLAVE_SOUTH = 0;
                      TRISA.B5 = 1;
                      nextPulse = NORTH;
                      i = 0;
                      pulseACTIVE = 0;
                  }
               }
            }

     }


//******************************************************************************
// Low priority interrupt to handle the segment updates. The segment data will
// already be sent to external shift-register and this interrupt only sends the
// latch signal to lock the new segments.
//******************************************************************************
     if (INTCON.T0IF) {

         INTCON.T0IF = 0;                        // Nolla overflow flaggan
         digitCounter++;                         // Count 1 step up to next GRID to be displayed
         if (digitCounter >= 5) {                // Re-start counter if GRID was last displayed
             digitCounter = 0;
         }
         PORTC &= 0b00000111;                    // Turn grids off
         EUSART_LATCH = 1;                       // Latch new segmentdata
         EUSART_LATCH = 0;                       // Release latch
         PORTC &= GRID[digitCounter];            // Tänd ny anod enligt räknaren
         newTRANSFER = 0;
     }
}

[lillahuset]

Det är (såvitt jag kan se) enda bitvariabeln du initierar i deklarationen. Kan ju vara en kompilatorbugg.
Var är dina "#include"?

Ett litet påpekande, en char vet man inte om den kan vara 0..255 eller -128..127. Det är kompilatorberoende så om du förväntar dig något utanför 0..127 måste du deklarera den signed eller unsigned.

Om din kompilator har stdint.h rekommenderar jag att du använder de typerna. Då vet man alltid hur breda de är.

Om du får för dig att använda structar med bitfält i ska du vara beredd på minerad mark. Det är helt kompilatorberoende.

[Magnus_K]

Jag har inga #include, det tror jag programmet sköter själv. Bra svar va? Full koll

En char (eller unsigned char) är 0..255 och en signed char är -128..127. Så tolkar jag hjälpfilen i alla fall och det har fungerat hittills.

EDIT: Testade nu och det är verkligen bara för "bit" som jag får meddelandet. Inte för dom andra typer, precis som du noterade.

[lillahuset]

Men om du av någon anledning byter kompilator vet du inte om char är signed eller unsigned. Därav försiktighetsregeln att en char ska hålla sig inom 0..127.

[Magnus_K]

Du har en poäng där

Eventuellt inkluderar jag standardtyperna och döper om allt men det är bara om jag ror det iland.

Det låter som att Icecap har en förklaring men jag förstår den inte. Har någon lust att förklara?

[Icecap]

Magnus_K: char är i C definierat som att inte vara specificerat till att vara signed eller unsigned.
Så ditt antagande är fel!

Ska den vara signed ska du definiera den som det och ska den vara unsigned ska du definiera den som det.

Och felet för bit är - som jag skrev tidigare - för att samma byte som de bits sätts i får upp till 8 olika värden.
och lösningen är - som jag skrev tidigare - att inte sätta dom vid deklarationen men sätta dom i rätt läge vid programmets initiering, då vet du att den blir rätt.

I det hela tagit verkar mycket av din programmering baserat på antagande istället för visshet.

EDIT: Ponera att du har ett antal BOOL (bit) som du ger ett värde.
unsigned char X0 : 1 = 0;
unsigned char X1 : 1 = 1;
osv.

Dessa bits placeras någonstans inom en eller fler bytes och kompilern kan inte hålla reda på vilken bit som kommer i vilken byte, det är nämligen linkern som gör detta.

Alltså kan linkern konstatera att samma byte kan få upp till 8 olika assignments utan att kunde veta vilken som är vilken. Detta utlöser en error.

Lösningen: Deklarera skiten rätt!

Kod: Markera allt

union
  {
  unsigned char All = 0x11; // Detta värde sätter alla bits samtidig, Flag_0 & 4 = 1, resten = 0
  struct
    {
    unsigned char Flag_0 : 1;
    unsigned char Flag_1 : 1;
    unsigned char Flag_2 : 1;
    unsigned char Flag_3 : 1;
    unsigned char Flag_4 : 1;
    unsigned char Flag_5 : 1;
    unsigned char Flag_6 : 1;
    unsigned char Flag_7 : 1;
    } Bits;
  } Flags;

[Magnus_K]

Dessa bits placeras någonstans inom en eller fler bytes och kompilern kan inte hålla reda på vilken bit som kommer i vilken byte, det är nämligen linkern som gör detta.

Alltså kan linkern konstatera att samma byte kan få upp till 8 olika assignments utan att kunde veta vilken som är vilken. Detta utlöser en error.

Lösningen: Deklarera skiten rätt!

Det här hjälpte. Tackar för det!
Öppnade hjälpfilen igen och nu när jag visste lite mer vad jag skulle leta efter så ser jag nu att det står:

Note :
Bit variables can not be initialized.
Bit variables can not be members of structures and unions.
Bit variables do not have addresses, therefore unary operator & (address of) is not applicable to these variables.

Hänger tyvärr inte med så mycket i dit kod-exempel men tids nog så kan jag ju alltid gå tillbaka och göra ett nytt försök.

I det hela tagit verkar mycket av din programmering baserat på antagande istället för visshet.

Ja du Icecap, det är precis så det är.

EDIT: Tog bort värdet vid deklarationen och lade till slaveRUNNING = 1; i main() men ovanför while(1) och programmet kompilerar nu utan fel.

[SvenAndersJ]

Datatypen bool är en boolesk datatyp, och kan vara TRUE eller FALSE.
Prova att byta din etta mot TRUE.