I use ATmega32 to interrupt every 32 ms in order to do some arbitrary things that are not very important at the moment.I use the overflow timer timer0 to interrupt, which works predictably and perfectly.
My problem is that I have a global variable:
volatile int isSampling;
This is not written to the interrupt vector. I read that the integer must be volatile in order to remove the compiler optimization option, but I declared it as volatile and it still doesn't work.
volatile
#include <AVR/IO.h> #include <util/delay.h> #include <avr/interrupt.h> char studentID[12] = {'S',1,2,3,4,5,6,7,'A','B','C','D'}; char buffer[72]; //Max bitlength = 6. * studentID length char repcount[72]; int pointer; volatile int isSampling; void setup(void); void startup(void); void loadValue(unsigned char loadedValue); void processValue(unsigned char processedValue, short bitLength); void sendDot(void); void sendDash(void); int main(){ setup(); while(1) { if (isSampling == 1){ startup(); int i; for (i = 0; i < 12; i++){ loadValue(studentID[i]); //Flash lights after letter sent. _delay_ms(500); PORTB = 0xF0; _delay_ms(500); } } } } void setup(void){ DDRB = 0xFF; sei(); TCCR0 = TCCR0 | 0x05; TIMSK|=(1<<TOIE0); TCNT0 = 0; pointer = 0; isSampling = 1; } ISR(TIMER0_OVF_vect) { //Every 32ms this interrupt vector is called. isSampling = 0; } void startup(void){ //Play LED startup pattern int i; for (i = 0; i < 4; i++){ PORTB = 0b11110011; //Bit 5 is constantly sampled. 4 is output _delay_ms(250); PORTB = PORTB & 0x00; _delay_ms(250); } _delay_ms(500); _delay_ms(500); } void loadValue(unsigned char loadedValue){ switch (loadedValue){ case 1: processValue(0b01111000, 5); case 2: processValue(0b00111000, 5); case 3: processValue(0b00011000, 5); case 4: processValue(0b00001000, 5); case 5: processValue(0b00000000, 5); case 6: processValue(0b10000000, 5); case 7: processValue(0b11000000, 5); case 8: processValue(0b11100000, 5); case 9: processValue(0b11110000, 5); case 0: processValue(0b11111000, 5); case 'A': processValue(0b01000000, 2); case 'B': processValue(0b10000000, 4); case 'C': processValue(0b10100000, 4); case 'D': processValue(0b10000000, 3); case 'E': processValue(0b00000000, 1); case 'F': processValue(0b00100000, 4); case 'G': processValue(0b11000000, 3); case 'H': processValue(0b00000000, 4); case 'I': processValue(0b00000000, 2); case 'J': processValue(0b01110000, 4); case 'K': processValue(0b10100000, 3); case 'L': processValue(0b01000000, 4); case 'M': processValue(0b11000000, 2); case 'N': processValue(0b10000000, 2); case 'O': processValue(0b11100000, 3); case 'P': processValue(0b01100000, 4); case 'Q': processValue(0b11010000, 4); case 'R': processValue(0b01000000, 3); case 'S': processValue(0b00000000, 3); case 'T': processValue(0b10000000, 1); case 'U': processValue(0b00100000, 3); case 'V': processValue(0b00010000, 4); case 'W': processValue(0b01100000, 3); case 'X': processValue(0b10010000, 4); case 'Y': processValue(0b10110000, 4); case 'Z': processValue(0b11000000, 4); case '.': processValue(0b01010100, 6); case ',': processValue(0b11001100, 6); case '?': processValue(0b00110000, 6); case '!': processValue(0b00110000, 5); case ':': processValue(0b11100000, 6); case '=': processValue(0b10001000, 5); } } void processValue(unsigned char processedValue, short bitLength){ unsigned char result; int i; //Enter Loop at the length of bits in numerical morse code for (i = 0; i < bitLength; i++){ result = processedValue & 0x80; processedValue = processedValue << 1; if (result) sendDash(); if (!result) sendDot(); _delay_ms(1000); } } void sendDot(void){ //Send Dot PORTB = 0x05; _delay_ms(250); PORTB = 0x00; } void sendDash(void){ //Send Dash PORTB = 0x06; _delay_ms(750); PORTB = 0x00; }
Ok, I found a violation code that causes the problem, but I'm not sure why it causes it. When I loadValue(studentID[i]) from the main while loop, the code works as predicted. But when I get it back, it breaks down again.
loadValue(studentID[i])
The _delay_ms (500) lines cause the problem, as Oli Charlworth speaks of. The _delay_ms () function can cause unpredictable behavior if it is set to high (over 250 ms).
Not sure if this explains the problem, but don't you deliberately have a break after each switch case value?
a problem occurred while defining a char array
char studentID[12] = {'S',1,2,3,4,5,6,7,'A','B','C','D'};
the number 1,2, ..., 7 should look lower
char studentID[12] = {'S','1','2','3','4','5','6','7','A','B','C','D'};