Ovládání čtyřciferné sedmisegmentovky + čítačů pulzů – Mikrokontroléry – Fórum – Programujte.com

Ahoj, prosím o radu s tímto kódem: (Čítače pulzů v TIMER0 fungují, problém je někde v TIMER2=zobrazování čísel)

Budu moc vděčný za odhalení problému! Díky!

#define F_CPU 4000000UL 
#include <avr/io.h> 
#include <util/delay.h> 
#include <avr/interrupt.h> 
#include <math.h> 

volatile unsigned int cislice; 
volatile unsigned int cislo; 
volatile unsigned char T1; 
volatile unsigned char T2; 
volatile unsigned char T3; 

////////////////////////////////////////////////////////////////////////// 
// TIMER 0 
////////////////////////////////////////////////////////////////////////// 
ISR (TIMER0_OVF_vect) 
{ 
TCNT0 = 180; // preruseni po 19,2ms 
T1++; 
T2++; 
////////////////////////////////////////////////////////////////////////// 
// FCE PRICITANI PULZU - (PB3) 
////////////////////////////////////////////////////////////////////////// 
switch (T1)//kazdejch 19,2s scannuje pulz 
{ 
case 1: 
if ((!(PINB&0b00001000))==1){ //pokud neprisel pulz 
T1=0; 
} 
break; 

case 4: 
if ((!(PINB&0b00001000))==0){ 
cislo=cislo+5; 
}
else{ 
T1=0; 
} 
break; 

case 8: 
T1=0; 
break; 
}
////////////////////////////////////////////////////////////////////////// 
// ODECITANI PULZU -(PB2) 
////////////////////////////////////////////////////////////////////////// 
switch (T2)//kazdejch 19,2s scannuje pulz 
{ 
case 1: 
if ((!(PINB&0b00000100))==1){ 
T2=0; 
} 
break; 

case 2: 
if ((!(PINB&0b00000100))==0){ //pokud prisel pulz if ((!(PINB&0b00000100))==0) 
cislo--; 
} 
else { //pokud tady neni pulz, tak neceka do konce, ale jde na zacatek cekani 
T2=0; 
} 
break; 

case 3: 
T2=0; 
break; 
} 
} 
////////////////////////////////////////////////////////////////////////// 
// TIMER 2 
////////////////////////////////////////////////////////////////////////// 
ISR (TIMER2_OVF_vect) 
{ 
TCNT0 = 205; //preruseni po 12,8ms 
T3++;
switch (T3) 
{ 
case 1: 
PORTC|= (0 << PC2); PORTC|= (1 << PC5);//PC5 -ANODA TISICE 
if (cislo>=1000){ 
cislice=cislo/1000; 
cislo=cislo-(cislice*1000); 
} 
else{ 
cislice=10; //zobrazi se - 
} 
break; 

case 2: 
PORTC|= (0 << PC5);PORTC|= (1 << PC4);//PC4 -ANODA STOVKY 
if (cislo>=100){ 
cislice=cislo/100; 
cislo=cislo-(cislice*100); 
} 
else{ 
cislice=10; //zobrazi se - 
} 
break; 

case 3: 
cislice=cislo/100; 
PORTC|= (0 << PC4);PORTC|= (1 << PC3);//PC3 -ANODA DESITKY 
if (cislo>=10){ 
cislice=cislo/10; 
cislo=cislo-(cislice*10); 
} 
else{ 
cislice=10; //zobrazi se - 
} 
break; 

case 4: 
PORTC|= (0 << PC3);PORTC|= (1 << PC2); //PC2 -ANODA JEDNOTKY 
cislice=cislo; 
T3=0;//vymaze casovaci promennou 
break; 
} 
ukazC(cislice); 
} 
////////////////////////////////////////////////////////////////////////// 
// ZOBRAZOVANI CISEL 
////////////////////////////////////////////////////////////////////////// 
void ukazC (char cislice) 
{ 
switch (cislice) 
{ 
case 0: PORTD = 0b11000000; break; 
case 1: PORTD = 0b11111001; break; 
case 2: PORTD = 0b10100100; break; 
case 3: PORTD = 0b10110000; break; 
case 4: PORTD = 0b10011001; break; 
case 5: PORTD = 0b10010010; break; 
case 6: PORTD = 0b10000010; break; 
case 7: PORTD = 0b11011000; break; 
case 8: PORTD = 0b10000000; break; 
case 9: PORTD = 0b10010000; break; 
default: PORTD = 0b10111111; break; //prostredni vodorovna cara 
//0b01111111, //tecka 
//0b11111111 //nic 
} 
} 
////////////////////////////////////////////////////////////////////////// 
// HLAVNI FUNKCE 
////////////////////////////////////////////////////////////////////////// 
int main (void) 
{
DDRB=0b00110010; //1=vystup, 0=vstup ///F7=>preklad programu 
DDRC=0b00111100; //C2-C5 jsou spolecny anody 
DDRD=0xff; //sedmisegment-vse vystupy 
//PORTB|= (1 << PB1); //zapnuti proudu nafurt
PORTD = 0b11111111; 
while(1) 
{ 
TCCR0 |= (1 << CS02) | (1 << CS00); // preddelicka /1024 //TCCR0 = 0b00000101;TIMSK = 0b00000011; 
TIMSK|= (1 << TOIE0);// prerušenie pri pretečení TCNT0 

//TIMER2 
TCCR2 |= (1 << CS22) | (1 << CS21)| (1 << CS20); // preddelicka /1024 //TCCR0 = 0b00000101;TIMSK = 0b00000011;
TIMSK|= (1 << TOIE2);// prerušenie pri pretečení TCNT2 

sei(); //povol globálne prerušenia 

PORTB=0b00110000; 
_delay_ms(40); 
PORTB ^= (1 << PB5); 
_delay_ms(100); 
} 
}

co to dělá nebo nedělá? Těžko hledat když nevíme co. Jaké je zapojení HW?

hu

napriklad:   PORTC |= (0 << PC4);

0 << 4 = 0;   0 | cokoliv = cokoliv;  (stejne cokoliv jako pred tim)

pokud chces vynulovat bit, tak musis  pres  &  a jeste k tomu napriklad:   PORTC &= ~(1<<PC4)

jinak existuje makro  _BV(x) ktery se vymeni za   (1 << (x)) a je mnohem citelnejsi

Když jsem dělal dekodování číslic na stav portu, dělal jsem to přes pole.  

uint_8 dekoder[] = {0x25, 0x89, 0xaf, ... } //stavy portu pro jednotlive cifry

PORTB = dekoder[cislo];

hu

Díky, nulování portu jsem opravil

Má to být čítač pulzů, ty to počítá dobře (V časovači 0, odzkoušel jsem to na počítání od 0 do 9),

Teď dělá problém to zobrazování čísel - konkrétně přepínání 1.-4. sedmisegmentovka. Většinou čísla blbě problikávají..někdy je na všech segmentech stejnej znak, při úpravách se to pak změnilo...

To máš multiplexovaný displej? Pozor na max proud portů. Jinak je vhodné přepínání míst provádět při zhasnutém displeji.

hu

a kdyz jsou pomaly tranzistory, tak i chvili pockat, aby tam nebyli duchove

Displej je multiplexovany-spolecne anody

Chyba bude pravdepodobne tady:

//////////////////////////////////////////////////////////////////////////
// TIMER 2 - DISPLEJ
//////////////////////////////////////////////////////////////////////////
ISR (TIMER2_OVF_vect)
{
    PORTD = 0b11111111;
    TCNT0 = 253; //preruseni po 12,8ms
    T3++;
    
    
    switch (cislice){
        case 0: PORTD = 0b11000000; break;
        case 1: PORTD = 0b11111001; break;
        case 2: PORTD = 0b10100100; break;
        case 3: PORTD = 0b10110000; break;
        case 4: PORTD = 0b10011001; break;
        case 5: PORTD = 0b10010010; break;
        case 6: PORTD = 0b10000010; break;
        case 7: PORTD = 0b11011000; break;
        case 8: PORTD = 0b10000000; break;
        case 9: PORTD = 0b10010000; break;
        default: PORTD = 0b10111111; break; //prostredni vodorovna cara
        //0b01111111, //tecka
        //0b11111111 //nic
    }
    
    switch (T3){
        case 1:
        PORTC &= ~(1<<PC2);
        PORTC|= (1 << PC5);//PC5 -ANODA TISICE
            if (cislo>=1000){
            cislice=cislo/1000;
            cislo=cislo-(cislice*1000);
            }
            else{
            cislice=10; //zobrazi se -
            }
            break;
    
        case 2:
        PORTC &= ~(1<<PC5);
        PORTC|= (1 << PC4);//PC4 -ANODA STOVKY
                if (cislo>=100){
                cislice=cislo/100;
                cislo=cislo-(cislice*100);
                }
                else{
                cislice=10; //zobrazi se -
                }
                break;
    
            case 3:
            cislice=cislo/100;
            PORTC &= ~(1<<PC4);
            PORTC|= (1 << PC3);//PC3 -ANODA DESITKY
                if (cislo>=10){
                cislice=cislo/10;
                cislo=cislo-(cislice*10);
                }
                else{
                cislice=10; //zobrazi se -
                }
            break;
    
            case 4:
            PORTC &= ~(1<<PC3);
            PORTC|= (1 << PC2); //PC2 -ANODA JEDNOTKY
            cislice=cislo;
            T3=0;//vymaze casovaci promennou
            break;
    }
}

#7 KIIV
na společné anody (nebo katody?) by ty tranzistory měli být. Že v C je každý příkaz několik instrukcí MCU, stačilo postupovat tak, že zhasnu displej přes segmenty, přepnu společné anody a zapnu segmenty. Pro buzení segmentů přímo z portů je proud silně omezen - co jsem to před nějakou dobou dělal, vycházelo asi 6mA na segment a muselo to být rozházený na více portů.

hu

Takze spinas PNP tranzistorem na +? Pak je vystup invertovany... tudiz spatne

#9 hlucheucho
kdyz by mel nejakej nizko prikonovej s 2mA na segment, spravny rezistory, tak to ten port utahne.. je to cca 14mA ale tahat pres to 7 segmentu po 20mA, to je mimo specifikaci o asi 100mA, spis vic.. a jeste to bude menit jas podle poctu sviticich segmentu...

Já tam teď nemám žádnej tranzistor ;) Nedávno jsem viděl zapojení, kde to normálně fungovalo,tak jsem tam zatím nic nedal...

Je to tady:

http://www.ok1kvk.cz/web/index.php/krouek-elektroniky/452-digitalni-hodiny-s-atmega8

Mám stejnej displej a víceméně i rozložení pinů...

Vůbec netuším, jak to má HW zapojené, jaký displej je. 

Kromě toho ještě zobrazování téhož všude může mít příčinu i v příliš rychlém MPX. Vhodné je max. 100 zobrazení za s, jinak to začnou silně ovlivňovat parazitní kapacity.

hu

A Když to tady tak řešíme, tak mi prosím rovnou řekněte, jakej tranzistor je nejlepší ;) (Ideálně nějakej v čipovým pouzdře)

Na PB5 (první - tísícovej segment) chodí čísla...

Na ostatních segmentech ve viditelnejch intervalech problikává pomlčka (vychází ze switch(cislice)

no v tom clanku jede docela na urovni "chvili to asi fungovat bude" ale pro 70+ mA na jeden port je to mimo absolutni pripustny hodnoty a casem to odejde... dat tam tak 3-4mA na segment, tak by to mohlo i jet bez tranzistoru...

OK, dodám tranzistor!

Bude stačit domácí BC547?

S těmi odpory ten displej bude bludičkovat. Aby svítil dobře, potřebuje asi 8 mA na segment, s ohledem na porty MCU to musíš ubrat na asi 6 mA. Na každém segmentu proud vynásobíš počtem míst, takže ti na portu vychází 24 mA. Pro červený LED s úbytkem napětí asi 1V můžeš počítat s úbytkem na odporech asi 3,5V. Podle ohmova zákona odpory v segmentech budou asi 150 ohm.

Kolik teče společnou elektrodou? Nejhorší případ - 7 segmentů představuje 7 x 24 mA. Takže tranzistor, který spíná společnou elektrodu, musí zvládnout asi 170 mA. Pokud nechceš invertovat výstupy pro ovládání spol. anod, lze použít BC639 jako emitorový sledovače s odpory mezi B a E asi 680 ohm. Pro velký úbytky na tranzistorech (asi 0,6 V) je toto řešení nevhodné pro zelený LED. z tohoto důvodu jsem použil ve svém zařízení MOS P a výstupy pro řízení anod jsou aktivní v L (tedy invertované). 

Pokud se dobře pamatuji, všechny katody na jednom portu také nejsou vhodné s ohledem na součet proudů jednoho portu. To jsem řešil tak, že jsem katody rozdělil na dva porty. Pro více informací tě odkážu na datasheet.

hu

#12 pirat077
zase jedna "super konstrukce", která vůbec nerespektuje údaje výrobce.

hu

OK, díky, podívám se na to a doladím ;)

Každopádně ta nefunkčnost bude skrytá v SW...s tím si nevím rady .(

S tímhle zapojením bych dál neexperimentoval, hrozí poškození MCU.

Schéma připojení displeje ti mohu poslat zítra, ale odmáznu to tak, aby to byl jen ten displej s tranzistory a odpory a MCU

Dá se to i převrátit vzhůru nohama. Požít LED se spol katodou, spol. katody budit tranzistorovým polem např ULN2003 a anody segmentů budit z portů MCU.

hu

Díky, schéma připojení by bylo super.

Bohužel mám právě na stole sedmisegmentovku se společnými anodami. Jinak by ULN byla jasná volba...

ATmega8 se dnes dá pořídit za dvacku....a pokud to někomu nějakej ten pátek fungovalo, tak to musí fungovat i mě...a když se poškodí MCU, hned ho vyměním a nebude mě to extra mrzet.... ;)

Když to někomu fungovalo... Jeden kus se náhodou povede a dalších deset nechodí

hu

segmenty na katode jsou vetsinou zrovna docela vyhoda.. muzes k tomu hodit libovolne drivery konstantniho proudu a tak..

v podstatě je problém, když má MCU současně počítat impulzy a k tomu multiplexovat displej. MCU může v daném momentě dělat jen jednu činnost. Obecně platí, že "mnoho zajíců = psova smrt". Dvě věci najednou se dají sice dělat, ale jen s blbými výsledky u obou věcí.

Buďto budeš dobře multiplexovat, aby displej svítil a utečou ti pulzy nebo budeš dobře počítat pulzy a žádný ti neuteče, ale zobrazování bude zoufalé.

Co tak dva MCU? Jeden bude počítat pulzy a přes SPI předá data druhému MCU, který je bude multiplexovat na LED, když už to teda musí být pomocí mikropočítače.

Ono to jde udělat docela elegantně třeba pomocí 4534 dokonce na 5 míst nebo pomocí čtyřech 40110, které umí dokonce počítat nahoru i dolů....  No já vím, nebudeš s tím ani "top" ani "in", ale úplně "out", ale zase máš to hned a nemusíš nic programovat :)  Když  to uděláš s dvěma MCU, jak jsem ti radil právě nahoře, budeš teda super "top", ale nadřeš se jak vůl :)

Záleží na potřebě strojového času. MPX displeje moc náročný není. U čítače pulzů lze použít hardwarový čítač/časovač na čipu. Pokud není pak potřeba nějaký supervýpočet, je zbytečný tam cpát další hardware.

hu

Jedna HEF4534 umí počítat pulzy na 5 míst i bez mikropočítače. Třeba zde

http://www.jplabs.co.uk/projects/bh4534a.html

je návod na 5,5 místný čítač. Vyzkoušel jsem to na 5 míst. Vstupní hradlo jsem nahradil 2 diodami a odporem a krom HEF4534 jsem použil už jen jeden dvojitý D klopák, jeden dvojitý JK klopák a jeden dekodér BCD na 7-segmentový kód a 5 tranzistorů NPN.  Běželo mi to do 13,5 MHz při napájení 12 Volty nestabilizovaných.

... a když si spočítám cenu použitých IO, tak vyjdou odhadem 2x dráž než MCU se 4 tranzistory pro společné anody (nebo katody) a stabilizátorem 5V. Pro 5 míst by bylo 5 tranzistorů pro spol. anody a ULN2003 pro katody, to už by porty MCU nezvládaly.

hu

zapomenul jsi připočítat cenu za vývoj software pro MCU. To není malá položka. Zkus si nechat udělat takový software a zaplatíš za něj víc než za MCU.

Používání MCU se software má smysl pro sériovou výrobu, kde se náklady na software rozloží třeba do 10 000 kusů výrobků. U jednoho kusu je používání MCU naopak výraz zoufalství. Bohužel je smutné, když učitelé ve škole učí dnešní teens  všechno s MCU. Výsledkem je, když pak mají teens sestrojit jednoduché počitadlo pulzů, pak neumějí nic jiného než použít MCU, pro který ale neumí napsat software.  Pak se nedivme, že jsou nezaměstnatelní a hledají východisko v drogách.

#29 remmidemmi
Jestli se nedostali k jednocipum od elektroniky a logickych obvodu, tak ani ten logicky obvod nezvladnou navrhnout a postavit (nebo aspon nejak poradne).

A u jednoho kusu se pouziti mcu nazyva takzvane "ucit se" nebo "hobby" nebo "hrani si".

Proc v tom programu nema pole ale case strukturu?

#31 peter
Kdyz uz, tak pole konstant v PROGMEM a tahat to z nej. At se nezabira RAM, kdyz ji tam je jen par kB.

U použití logických obvodů je třeba počítat s návrhem schématu a DPS, to je taky drahá práce. Dále více IO, větší a složitější deska, někdy i nutnost použít dvouvrstvou DPS (její výroba je dražší, citelně u jednoho kusu - jsou to tisícové částky). Osazení většího počtu součástek je taky práce, zkus si někdy nechat nacenit osazení DPS. Málokdy se podaří kombinační nebo sekvenční logiku navrhnout hned napoprvé, takže to pak vede k úpravě, nakonec je to dobastlený. S MCU se to většinou povede bez bastlení jen odladěním software. Pak to vypadá, že jsem to udělal hned napoprvý. Navíc je MCU + displej univerzální - na stejném hardware můžu udělat panelový voltmetr, časové relé či cokoliv jiného. Výsledkem je řešení pro více aplikací z jednoho polotovaru. Naproti tomu "klasická" CMOS logika se vyznačuje menším příkonem (s příchodem PicoPower MCU se tato výhoda vytrácí) a LS TTL vyšší rychlostí. Další výhodou "klasické" logiky je opravitelnost. Koupím logický IO, vyměním. U jednodušších zařízení mám šanci na základě "zpětného inženýrství" pochopit funkci a najít závadu. U jednočipu bez možnosti získat a nahrát software nemám šanci cokoliv opravit.

Že si schéma, DPS i software dělám sám, opravitelnost se dnes až tak neřeší a osazování DPS už asi budu muset nechat dělat dodavatelsky (práce pod mikroskopem mi moc nejde), vychází mi lépe MCU s dobře navrženou DPS jako polotovar pro řešení více aplikací.

hu

#30 KIIV
to je právě ten problém, že začínají od konce, od mikropočítačů a neumějí pospojovat všelijaká hradla :( . Ta chyba je ve škole, v osnovách, možná už v učitelích, kteří dost patrně také znají jen mikropočítače :) a jsou o pár hodin napřed , před svbými žáky :) :).  Třeba v Indii ve školách mají takové stavebnice, které jsou kostky se zdířkami. Na každé kostce je namalován jednoduchý obvod, třeba nějaké hradlo, tranzistor atp. a děcka ty kostky spojují kablíkama s banánkama a učí se a hrajou si. Dost možná by se to mohlo zavést i u nás a pak by absolventi ČVUT nepotřebovali arduino pro udělání blikače na jízdní kolo.