Zasady pisania programów pseudowielowątkowych na małych proc

char tab[16], indexisr, indexpg;

ISR()
{
  tab[indexisr++] = jakaswartosc;
}

main()
{
  while(1)
  {
// tu jakis inny kod obslugi czegokolwiek

    while(indexisr != indexpg)
    {
       LCD_WriteData(tab[indexpg])
       indexpg++;
    }

// tu jakis inny kod obslugi jeszcze czegos innego
  }
}

TMFEvent *TMFApp::msg[MESSAGE_QUEUE];
uint8_t TMFApp::Queue_Begin;
uint8_t TMFApp::Queue_End;

bool TMFApp::PutMessage(TMFEvent *e)
{
	bool ret=false;

	ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
	{
    	uint8_t qe=(Queue_End+1) % MESSAGE_QUEUE;
		uint8_t qb=Queue_Begin;

		uint8_t ql=(Queue_End-1) % MESSAGE_QUEUE;
		if(!((Queue_Begin!=Queue_End) && (memcmp(e, msg[ql], sizeof(TMFEvent))==0)))    //Don't insert message if it duplicates last message in queue
            if(qe!=qb)                                  //No space in queue
            {
                msg[Queue_End]=e;
                Queue_End=qe;
                ret=true;
                TMFPCCOMPAT_UPDATE_EVENTS(e, Queue_Begin,Queue_End)
            }
	}
    return ret;
}

TMFEvent *TMFApp::GetMessage()
{
	TMFEvent *e=NULL;

	ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
	{
    	if(Queue_Begin!=Queue_End)
		{
            TMFPCCOMPAT_UPDATE_EVENTS(e, Queue_Begin,Queue_End)

      		uint8_t q=Queue_Begin;
      		Queue_Begin=(Queue_Begin+1) % MESSAGE_QUEUE;
	  		e=msg[q];
		}
    }
    return e;
}

void TMFApp::DispatchMessage()
{
    TMFEvent *te=GetMessage();
    if(te)
    {

#ifdef INPUT_RotaryEncoder
		if(te->msg==CMD_Encoder)	//Check user activity to check if LCD and LCD backlight should be turned on
		{
			LCD->SetLCDOn(LCDDriver::LCD_FullPower);
			ETimer::Instance().PostProneEvent(InactivityTimer, LCD_BACKLIGHT_OFF);

			if((te->intval & (ENC_Pressed | ENC_JustReleased | ENC_JustPressed))==0)	//User rotated encoder without pressing it
			{
				TMFObject *topobj=ChangeFocus(te->byteval, GetList());
				SetList(topobj);    //In case top object changed
				delete te;
				return;
			}
		}
#endif

		if((te->msg==CMD_TimerEvent) && (te->param==InactivityTimer))	//Check if it is Timer message directed to TMFApp object
		{
			LCD->SetLCDOn(LCDDriver::LCD_LEDOff);	//Turn off LCD backlight
			delete te;
			return;
		}

        if(te->receiver)
		{
            bool ret=false;

            if(te->msg==CMD_Close) Close(te->receiver);
             else
            {
                TMFObject *tmpobj=te->receiver;

                while((tmpobj) && ((ret=tmpobj->DispatchMessage(te))==false))   //If message wasn't handled try if parent object can handle it
                {
                    tmpobj=tmpobj->GetParent();
                }
            }
		}
            else
        {
			if(GetList()) DispatchMessage(te,GetList());
        }

        delete te;
    }
}

void TMFApp::DispatchMessage(TMFEvent *e, TMFObject *obj)
{
	if(obj->GetNext()) DispatchMessage(e, (TMFObject*)obj->GetNext());
	else
	{
		if(IsAllChildsDisabled(obj)==false) DispatchMessage(e, (TMFObject*)obj->GetChild());
		else
		{
			obj->DispatchMessage(e);
		}
	}
}

#ifndef true
#define true 1
#endif

#ifndef false
#define false 0
#endif


typedef unsigned char bool;

#include <stdint.h>
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include "HD44780.h"	//to jest radzia
#include <avr/sfr_defs.h>
#include "TWI.h"		//i to też jest radzia

#define LICZBA_KANALOW      4 //cztery kanały- tu można zwiększyć ilość kanałów 
#define NAPIECIE_AKU_MIN	11.0
#define NAPIECIE_AKU_MAX	14.0
#define NAPIECIE_SOLAR_MIN  13.0
#define START_LADOWANIE		PORTB&=~(1 << PORTB4); // clear PORTB0      
#define STOP_LADOWANIE		PORTB|=(1<<PORTB4);	// set PORTB0
#define MASKA_ODCZYT		0b11110000
#define MASKA_WYJSCIE		0b11110000
#define PCFADDR 0x20
#define maska 0x01

volatile uint8_t flaga_pomiaru;
volatile uint8_t flaga_przycisku;
volatile uint8_t stan_przyciskow;
unsigned int napiecie[LICZBA_KANALOW];
unsigned int debounce(void);
void SetAdcKanal(void);	// prototyp

int main(void)	// tu jest początek main() i tu ustawiamy konfigurację rejestrów
{   
	char buffer_nap[LICZBA_KANALOW];
	char *text="Kolejne";
    char *text1="testy";
	uint8_t i;	
	uint8_t external_supply=0;
	uint8_t stany;
	int j, acc;
	char tab[9]="        ";

    sei();
    DDRB=255;
    PORTB=255;
	DDRC=0;
	PORTC=0xf0; 
 	TCCR0=_BV(CS00)|_BV(CS02);// TIMER0 przepełnia się co 16ms
    ADMUX = _BV(REFS0)|_BV(REFS1) ;//Wewnętrzne źródło napięcia odniesienia-ok.2.56V    |_BV(ADLAR)   
    ADCSRA = _BV(ADATE)|_BV(ADEN)|_BV(ADIE)|_BV(ADPS0)|_BV(ADPS1)|_BV(ADPS2)|_BV(ADSC);//|_BV(ADATE)   
	OCR0=127;					//ustawienie rejestru porównania w Timer0 na połowę zakresu
	SFIOR=_BV(ADTS0)|_BV(ADTS1); // ustawienie startu przetwarzania ADC po porównaniu z OCR0 Timer0
	TIMSK=_BV(TOIE0);

	TWSR = 0;                         //brak preskalera
	TWBR=72;

    LCD_Initalize();
    LCD_WriteText(text);
    LCD_GoTo(0,1);
    LCD_WriteText(text1);      
    _delay_ms(300);
    LCD_GoTo(0,0);
    LCD_WriteText("                ");// to jest szybciej niż LCD_Clear
	LCD_GoTo(0,1);
	LCD_WriteText("                ");
	LCD_GoTo(5,0);											//dopasować do swoich potrzeb
	LCD_WriteText("V");
	LCD_GoTo(5,1);
	LCD_WriteText("V");
	LCD_GoTo(12,0);
	LCD_WriteText("A aku");
	LCD_GoTo(12,1);
	LCD_WriteText("A solar");

	while(1)			//A tu zaczyna się nieskończona pętla
	{
		
		if(flaga_pomiaru)		//Tu sprawdzamy flagę i dlatego ten
						//fragment wykonuje się co 1/4s- bo co 1/4s jest wyzwalany ADC- porównaniu z OCR0 Timer0
		{			//Przez resztę czasu śpi.LCD też pokazuje co 1/4s.
			for(i = 0; i < LICZBA_KANALOW; i++)		//pętla pomysłu gaskoina
			{
			    if(i<2)
				{
			        LCD_GoTo(0,i);
			        LCD_WriteText("     ");
			        LCD_GoTo(0,i);
		        } 
				else
				{
				    LCD_GoTo(7,i-2);
				    LCD_WriteText("     ");
			        LCD_GoTo(7,i-2);
			    }
			    LCD_WriteText(dtostrf(napiecie[i]/50.0,5,2,buffer_nap));

				if(external_supply)
				{
					LCD_GoTo(20,0);
					LCD_WriteText("External supply");										
				}
				else
				{
					LCD_GoTo(20,0);
					LCD_WriteText("Solar is on    ");
				}

				
			}
	    flaga_pomiaru=0;	// A tu flagę kasujemy- po 1/4s znowu się ustawi
		}		//Tu się kończy ten fragment co się wykonuje co 1/4s

		if(flaga_przycisku>=4)	//Ten fragment wykonuje się co16ms x4 z Timer0
		{						// to też zrozumiałem dzięki pomocy sulfura
			static uint8_t toggle=1;
			uint8_t	stan_przyciskow;
			stan_przyciskow=debounce();
			
			if(stan_przyciskow==0x10)
			{
				if(toggle)
				{
				PORTB=(0x1|MASKA_WYJSCIE);//wyjście tylko na port0-3
				toggle=0;
				}
				else
				{
				PORTB=(0xC|MASKA_WYJSCIE);
				toggle=1;
				}

				twistart();
				twiwrite(0x40 | (PCFADDR << 1));
				twiwrite(0xff);
				twistop();

				twistart();
				twiwrite(0x41 | (PCFADDR << 1));
				stany = twiread(NOACK);
				twistop();

				LCD_GoTo(20,1);

				int i = 128;					//pomysł zastąpienia itoa() autorstwa sulfura
				for (; i; i>>=1)
				LCD_WriteData((stany&i?'1':'0'));
			}

			if(stan_przyciskow==0x20)
			{
				if(toggle)
				{
				PORTB=(0x2|MASKA_WYJSCIE);
				toggle=0;
				}
				else
				{
				PORTB=(0xC|MASKA_WYJSCIE);
				toggle=1;
				}

				twistart();
				twiwrite(0x40 | (PCFADDR << 1));
				twiwrite(0xff);
				twistop();

				twistart();
				twiwrite(0x41 | (PCFADDR << 1));
				stany = twiread(NOACK);
				twistop();

				LCD_GoTo(20,1);

				for(j=0; j<8; j++)			// a to pomysł tymona_x- też pięknie działa 
				{
			    acc=7-j;
			    tab[j] = ((stany >> acc) & maska) + 0x30;
				}
				LCD_WriteText(tab);
											// nie sprawdziłem jeszcze pomysłu michałko- ale wkrótce sprawdzę
			}
		flaga_przycisku=0;
		}	

	// a tu można wsadzić resztę programu która się bedzie wykonywała z pełną prędkością 
			if(((napiecie[0]/50.0)<NAPIECIE_AKU_MIN)&&((napiecie[1]/50.0)<NAPIECIE_SOLAR_MIN))
			{
				START_LADOWANIE	//ładowanie włączamy stanem niskim
				external_supply=1;
			}
			if(((napiecie[1]/50.0)>=NAPIECIE_SOLAR_MIN)||((napiecie[0]/50.0)>=NAPIECIE_AKU_MAX))
			{
				STOP_LADOWANIE	//a wyłączamy stanem wysokim
				external_supply=0;
			}
	}
}

ISR(ADC_vect)//a tu przerwanie od ADC- ADC jest wyzwalane przez OCR TIMER0 co 8ms  
{            //ale pomiar wyświetlany jest co 256ms
	static uint8_t liczniczek_pomiaru;//TIMER0 nie starcza na 1/4s- to niech liczniczek to zlicza 
	liczniczek_pomiaru++;
	if(liczniczek_pomiaru>=32)//32x8ms- 256ms
		{
		liczniczek_pomiaru=0;
		SetAdcKanal();//ta funkcja zmienia kanal i zapisuje w tablicę napiecie[kanal]
		flaga_pomiaru=1;	//flaga pomiaru ustawia się co 256ms
		}
	TIFR |= (1 << OCF0); // a tu nie było przerwania od OCR0 Timer0- ale skasować flagę trzeba- no to kasujemy 
}						// w ten sposób wykorzystujemy to przerwanie też jako timer
						// sposób trochę pokręcony- sposób gaskoina jest prostszy do zrozumienia
void SetAdcKanal(void)// a tu funkcja zmieniająca kanały- definicja	- to chyba też gaskoina
{
	static uint8_t kanal;
	ADMUX = ((ADMUX&0xE0)+ kanal);//zmienić kanał	
	napiecie[kanal++]=ADC;			// zapisać pomiar w tablicę
    if(kanal>=LICZBA_KANALOW)		
	kanal=0;  
} 

ISR(TIMER0_OVF_vect)		// no ale przerwanie od TIMER0 też wykorzystamy- do debounce
{
	flaga_przycisku++;
}

unsigned int debounce(void)// funkcja Freddiego Chopina
{
	static unsigned int last;
	unsigned int port;
	unsigned int wynik;
   
	port = PINC&MASKA_ODCZYT; //odczyt tylko z poza maski
    wynik=port&(~last);
    last=port;
   
   return wynik;
} 

while(1)
{
   if(flaga_1) <- flaga ustawiana przez przerwanie
   {
      zrob_cos();
      flaga_1 = 0;
   }
   if(flaga_2)
   {
      jakas_funkcja(); <- ta funkcja działa długo, powiedzmy ok. 1 minuty
      flaga_2 = 0;
   }
}

while(1) {};

void func(void)
{
	static krok = 1;

	switch(krok)
	{
		case 1: 
		{
			krok = 2;
			break;
		}

		case 2: 
		{
			krok = 3;
			break;
		}
		
		case 3: 
		{
			krok = 1;
			break;
		}
	}
}