Vad innebär "Too many initializers" som kompileringsfel?
- Magnus_K
- EF Sponsor
- Inlägg: 5854
- Blev medlem: 4 januari 2010, 17:53:25
- Ort: Skogen mellan Uppsala-Gävle
Vad innebär "Too many initializers" som kompileringsfel?
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.
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.
Re: Vad innebär "Too many initializers" som kompileringsfel?
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...
I så fall kan du posta en "reproducer" som visar felet.
Men det är väl bara att leta efter "slaveRUNNING" i koden...
Re: Vad innebär "Too many initializers" som kompileringsfel?
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.
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.
Re: Vad innebär "Too many initializers" som kompileringsfel?
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?
Är det nåt som är specifikt för en viss kompilator? Hur är typen definierad?
Re: Vad innebär "Too many initializers" som kompileringsfel?
#include "stdbool.h"
typedef bool bit;
typedef bool bit;
Re: Vad innebär "Too many initializers" som kompileringsfel?
Posta all kod, ditt exempel är troligen inte det som ger felmeddelandet, brukar vara något med arrays.
Har du kollat raden innan?
Har du kollat raden innan?
- Magnus_K
- EF Sponsor
- Inlägg: 5854
- Blev medlem: 4 januari 2010, 17:53:25
- Ort: Skogen mellan Uppsala-Gävle
Re: Vad innebär "Too many initializers" som kompileringsfel?
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!
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
- Gått bort
- Inlägg: 13969
- Blev medlem: 3 juli 2008, 08:13:14
- Ort: Norrköping
Re: Vad innebär "Too many initializers" som kompileringsfel?
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.
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
- EF Sponsor
- Inlägg: 5854
- Blev medlem: 4 januari 2010, 17:53:25
- Ort: Skogen mellan Uppsala-Gävle
Re: Vad innebär "Too many initializers" som kompileringsfel?
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.
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
- Gått bort
- Inlägg: 13969
- Blev medlem: 3 juli 2008, 08:13:14
- Ort: Norrköping
Re: Vad innebär "Too many initializers" som kompileringsfel?
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
- EF Sponsor
- Inlägg: 5854
- Blev medlem: 4 januari 2010, 17:53:25
- Ort: Skogen mellan Uppsala-Gävle
Re: Vad innebär "Too many initializers" som kompileringsfel?
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?
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?
Re: Vad innebär "Too many initializers" som kompileringsfel?
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!
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
- EF Sponsor
- Inlägg: 5854
- Blev medlem: 4 januari 2010, 17:53:25
- Ort: Skogen mellan Uppsala-Gävle
Re: Vad innebär "Too many initializers" som kompileringsfel?
Det här hjälpte. Tackar för det!Icecap skrev: 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!
Ö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:
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.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.
Ja du Icecap, det är precis så det är.Icecap skrev:I det hela tagit verkar mycket av din programmering baserat på antagande istället för visshet.
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.
-
- Inlägg: 95
- Blev medlem: 13 februari 2016, 12:18:58
- Ort: Holm, Halmstad
Re: Vad innebär "Too many initializers" som kompileringsfel?
Datatypen bool är en boolesk datatyp, och kan vara TRUE eller FALSE.
Prova att byta din etta mot TRUE.
Prova att byta din etta mot TRUE.