C Array Initialization getting error - c

Question

I have tried to define a 2 dimension array in c language and initialize it with variables of float types but I have got this error:
"must be constant expression"
here is my code:
/*******************************************************
This program was created by the
CodeWizardAVR V3.12 Advanced
Automatic Program Generator
© Copyright 1998-2014 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project :
Version :
Date : 1/30/2017
Author :
Company :
Comments:
Chip type : ATmega8A
Program type : Application
AVR Core Clock frequency: 8.000000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 256
*******************************************************/
#include <mega8.h>
#include <stdio.h>
#include <delay.h>
#include <alcd.h>
#define A Hall_1
#define B Hall_2
#define C Hall_3
//...........................................................................................
// Declare your global variables here
float Hall_1 ,Hall_2 ,Hall_3 ;
int count=0;
//----------------------------------------------------------------------------------------------------
// Timer 0 overflow interrupt service routine
interrupt [TIM1_OVF] void timer1_ovf_isr(void)
{
count++;
}
//----------------------------------------------------------------------------------------------
// ADC interrupt service routine
interrupt [ADC_INT] void adc_isr(void)
{
}
//-----------------------------------------------------------------------------------------------
float adc_read(unsigned char);
float maxf(float , float , float);
float minf(float , float , float);
void commutate(unsigned char*);
//-----------------------------------------------------------------------------------------------
void main(void)
{
// Declare your local variables here
float comt_sequence[6][2]= {{B,A},{B,C},{A,C},{A,B},{C,B},{C,A}};
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 8000.000 kHz
TCCR1B=(0<<CS02) | (0<<CS01) | (0<<CS00);
TCNT1=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=(0<<OCIE2) | (0<<TOIE2) | (0<<TICIE1) | (0<<OCIE1A) | (0<<OCIE1B) | (0<<TOIE1) | (0<<TOIE0);
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
MCUCR=(0<<ISC11) | (0<<ISC10) | (0<<ISC01) | (0<<ISC00);
// ADC initialization
// ADC Clock frequency: 250.000 kHz
// ADC Voltage Reference: Int., cap. on AREF
// Only the 8 most significant bits of
// the AD conversion result are used
ADMUX= (1<<REFS1) | (1<<REFS0) | (1<<ADLAR) ;
ADCSRA=(1<<ADEN) | (0<<ADSC) | (0<<ADFR) | (0<<ADIF) | (0<<ADIE) | (1<<ADPS2) | (0<<ADPS1) | (1<<ADPS0);
SFIOR=(0<<ACME);
// Alphanumeric LCD initialization
// Connections are specified in the
// Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu:
// RS - PORTD Bit 0
// RD - PORTD Bit 1
// EN - PORTD Bit 2
// D4 - PORTD Bit 4
// D5 - PORTB Bit 6
// D6 - PORTB Bit 7
// D7 - PORTD Bit 5
// Characters/line: 16
lcd_init(40);
// Global enable interrupts
#asm("sei")
lcd_putsf("start");
delay_ms(500);
lcd_clear();
while (1)
{
unsigned char buffer[18] , s=0;
float m,n=0 , max_min[2];
TCCR1B=1; //start counting cycles
Hall_1 = adc_read(5);
Hall_2 = adc_read(4);
Hall_3 = adc_read(3);
m=maxf(Hall_1,Hall_2,Hall_3);
/*if(m == Hall_1)
lcd_putsf("Max= A ");
else if(m == Hall_2)
lcd_putsf("Max= B ");
else if(m == Hall_3)
lcd_putsf("Max= C ");
else
lcd_putsf("Error"); */
n=minf(Hall_1,Hall_2,Hall_3);
/*if(n == Hall_1)
lcd_putsf("Min= A");
else if(n == Hall_2)
lcd_putsf("Min= B");
else if(n == Hall_3)
lcd_putsf("Min= C");
else
lcd_putsf("Error");*/
max_min[0] = m;
max_min[1] = n;
s=count;
sprintf(buffer,"%5.4f %5.4f %d",max_min[0],max_min[1] ,TCNT1);
lcd_puts(buffer);
delay_ms(1000);
lcd_clear();
}
}
///////////////////////////////////////////////
float adc_read(unsigned char ch)
{
unsigned char lcd_buff[18];
float adc_data;
// select the corresponding channel 0~7
// ANDing with ’7' will always keep the value
// of ‘ch’ between 0 and 5 ""ATmega8 has 6 ADC channel 0-5""
ch &= 0b00000111; // AND operation with 5
ADMUX = (ADMUX & 0xF8)|ch; // clears the bottom 3 bits before ORing
// start single convertion
// write ’1' to ADSC
ADCSRA |= (1<<ADSC);
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
// Read the 8 most significant bits
// of the AD conversion result
adc_data=(ADCH * 2.56)/255;
//sprintf(lcd_buff," %5.3f ",adc_data);
//lcd_puts(lcd_buff);
//delay_ms(500);
return adc_data;
}
//------------------------------------------------------------------------------------------------
float maxf(float a , float b , float c) {
float m;
m = (a>b)?a:b;
m = (m>c)?m:c;
return m;
}
float minf(float a , float b , float c) {
float m;
m = (a<b)?a:b;
m = (m<c)?m:c;
return m;
}
//--------------------------------------------------------------------------------------
void commutate(unsigned char *max_min){
unsigned char x=0, i=0;
//unsigned char comt_pattern[6][2] = {(
for (i=0; i<6 ;i++)
if((max_min[0] == comt_sequence[i][0]) && (max_min[1] == comt_sequence[i][1])) x=i;
switch(x){
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
}
}
i add my whole code also i mention that Hall variables holds an ADC reading from a sensor and its values changes periodically what is my fault?
please help

Answer 1

You may not initialize arrays in C with static storage duration with non-constant initializers.
From the C Standard (6.7.9 Initialization)
4 All the expressions in an initializer for an object that has static
or thread storage duration shall be constant expressions or string
literals.
It seems your array is declared outside any function. If it is possible declare it in a function for example in main.

Answer 2

When creating an array like that, its size must be constant, because C doesn't allow non-constant values for the size of an array.
C99 standard section 6.7.8 (Initialization), point 4:
All the expressions in an initializer for an object that has static
storage duration shall be constant expressions or string literals.
I did changes your code. try it.
#include <stdio.h>
#define Hall_1 10
#define Hall_2 20
#define Hall_3 30
int main()
{
float A,B,C;
A = Hall_1;
B = Hall_2;
C = Hall_3;
float commutate_sequence[6][2]= {{B,A},{B,C},{A,C},{A,B},{C,B},{C,A}};
return 0;
}

Answer 3

I changed code as follow and it works now:
#define A Hall_1
#define B Hall_2
#define C Hall_3
void commutate(unsigned char max_min)
{ unsigned char X=0, i=0;
float comt_sequence[6][2]= { (&Hall_2,&Hall_1) , (&Hall_2,&Hall_3),(Hall_1,&Hall_3) , (&Hall_1,&Hall_2), &Hall_3,&Hall_2) , (&Hall_3,&Hall_1) };
for (i=0; i<6 ;i++)
{ if( (max_min[0] == (*comt_sequence[i][0])) && (max_min[1] == (*comt_sequence[i][1]))) X=i;}