ATNEL tech-forum

Re: wyświetlacz fluorescencyjny

2016-09-16T17:44:38+01:00

Witam,
Obiecany kod. - niestety trochę tasiemiec nie optymalizowany, ale działa.
Problem z tablicą pozostał,
ale będzie kontynuowany w następnej wersji jak się trochę poduczę.
Zamysły już są w jaki sposób to ogarnąć.
............................................................................................
Tu można dowolnie wybierać:
PORTY A B C D,
PINY 0 - 7
załączanie stanem wysokim lub niskim,
niezależnie czy to segmenty czy cyferblaty-(wspólne anody lub katody).
.............................................................................................
Dla odróżnienia cyfra_1 - (wyświetlana cyfra 1 ), od cyfra_pierwsza, te ostatnie nazwałem cyferblat_1.

Na potrzeby edukacyjne Wojtka i jak ktoś ma ochotę to proszę.
Nieraz na szybko może do testów się przyda.

[syntax=c]/*
* main.c
*
* Created on: 14 wrz 2016
* Author: Daro69
*
*/

#include
#include
#include

/************************************************************DARO69************************************************************
*
Dla wojciechgorzolka - kolegi z forum "ATNEL"
*
X XXXXX XXXX 8.8. 8.8.8.8. <---max szesc cyferblatow-
X X X X
X X X X
X X X X
XXXXX XXXXX XXXX V.2. NA PORCIE A B C D
*
*
* DEFINICJE PINOW PORTOW I DDROW ZE WSPÓLNĄ ANODĄ LUB KATODĄ
*
**********************************************************DARO69**************************************************************/

#define LICZBA_CYFERBLATOW 2// <----WYBIERZ LICZBĘ ANOD-KATOD

#if LICZBA_CYFERBLATOW

#define ZALACZANIE_CYFERBLATOW 1 // <----1-STANEM WYSOKIM , 0-STANEM NISKIM
#define ZALACZANIE_SEGMENTOW 0// <----1-STANEM WYSOKIM , 0-STANEM NISKIM

#if LICZBA_CYFERBLATOW
#define CYFERBLAT_1 (1<<0)// <----NR PINU PIERWSZEJ WSPOLNEJ ANODY-KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_1 PORTB// <----PORT PIERWSZEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_1 DDRB// <----DDR PIERWSZEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

#if LICZBA_CYFERBLATOW > 1
#define CYFERBLAT_2 (1<<7)// <----NR PINU DRUGIEJ WSPOLNEJ ANODY_KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_2 PORTD// <----PORT DRUGIEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_2 DDRD// <----DDR DRUGIEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

#if LICZBA_CYFERBLATOW > 2
#define CYFERBLAT_3 (1<<6)// <----NR PINU TRZECIEJ WSPOLNEJ ANODY_KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_3 PORTD// <----PORT TRZECIEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_3 DDRD// <----DDR TRZECIEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

#if LICZBA_CYFERBLATOW > 3
#define CYFERBLAT_4 (1<<5)// <----NR PINU CZWARTEJ WSPOLNEJ ANODY_KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_4 PORTD// <----PORT CZWARTEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_4 DDRD// <----DDR CZWARTEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

#if LICZBA_CYFERBLATOW > 4
#define CYFERBLAT_5 (1<<1)// <----NR PINU PIATEJ WSPOLNEJ ANODY_KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_5 PORTD// <----PORT PIATEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_5 DDRD// <----DDR PIATEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

#if LICZBA_CYFERBLATOW > 5
#define CYFERBLAT_6 (1<<2)// <----NR PINU SZOSTEJ WSPOLNEJ ANODY_KATODY " 0 1 2 3 4 5 6 7 "
#define PORT_CYFERBLAT_6 PORTD// <----PORT SZOSTEJ WSPOLNEJ ANODY-KATODY " PORTA PORTB PORTC PORTD "
#define DDR_CYFERBLAT_6 DDRD// <----DDR SZOSTEJ WSPOLNEJ ANODY-KATODY " DDRA DDRB DDRC DDRD"
#endif

/********************************************* -A- *********************************************
* -F- -B-
*DEFINICJE PINOW I PORTÓW Z SEGMENTAMI -G-
* -E- -C-
* ******************************************** -D--H-*********************************************/

/*SEGMENT A*/
#define DDR_A_SEGMENTDDRC// <----DDR SEGMENTU A
#define PORT_A_SEGMENTPORTC// <----PORT SEGMENTU A
#define A_SEGMENT(1<<0)// <----NR PINU SWGMENTU A
#define A_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU A

/*SEGMENT B*/
#define DDR_B_SEGMENT DDRC// <----DDR SEGMENTU B
#define PORT_B_SEGMENT PORTC// <----PORT SEGMENTU B
#define B_SEGMENT (1<<1)// <----NR PINU SWGMENTU B
#define B_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU B

/*SEGMENT C*/
#define DDR_C_SEGMENT DDRC// <----DDR SEGMENTU C
#define PORT_C_SEGMENT PORTC// <----PORT SEGMENTU C
#define C_SEGMENT (1<<2)// <----NR PINU SWGMENTU C
#define C_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU C

/*SEGMENT D*/
#define DDR_D_SEGMENT DDRC// <----DDR SEGMENTU D
#define PORT_D_SEGMENT PORTC// <----PORT SEGMENTU D
#define D_SEGMENT (1<<3)// <----NR PINU SWGMENTU D
#define D_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU D

/*SEGMENT E*/
#define DDR_E_SEGMENT DDRC// <----DDR SEGMENTU E
#define PORT_E_SEGMENT PORTC// <----PORT SEGMENTU E
#define E_SEGMENT (1<<4)// <----NR PINU SWGMENTU E
#define E_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU E

/*SEGMENT F*/
#define DDR_F_SEGMENT DDRC// <----DDR SEGMENTU F
#define PORT_F_SEGMENT PORTC// <----PORT SEGMENTU F
#define F_SEGMENT (1<<5)// <----NR PINU SWGMENTU F
#define F_SEGMENT_NA_PORCIE C// <----PORT SEGMENTU F

/*SEGMENT G*/
#define DDR_G_SEGMENT DDRD// <----DDR SEGMENTU G
#define PORT_G_SEGMENT PORTD// <----PORT SEGMENTU G
#define G_SEGMENT (1<<0)// <----NR PINU SWGMENTU G
#define G_SEGMENT_NA_PORCIE D// <----PORT SEGMENTU G

/*SEGMENT H*/
#define DDR_H_SEGMENT DDRB// <----DDR SEGMENTU H
#define PORT_H_SEGMENT PORTB// <----PORT SEGMENTU H
#define H_SEGMENT (1<<1)// <----NR PINU SWGMENTU H
#define H_SEGMENT_NA_PORCIE B// <----PORT SEGMENTU H

/******************************************************************************************************************************
*
* SPRAWDZANIE KTÓRE PORTY SĄ UzYWANE PRZEZ SEGMENTY
*
* ****************************************************************************************************************************/
#if(A_SEGMENT_NA_PORCIE==A || B_SEGMENT_NA_PORCIE==A || C_SEGMENT_NA_PORCIE==A || D_SEGMENT_NA_PORCIE==A || E_SEGMENT_NA_PORCIE==A || F_SEGMENT_NA_PORCIE==A ||G_SEGMENT_NA_PORCIE==A || H_SEGMENT_NA_PORCIE==A )
#define SEGMENTY_NA_PORCIE_A 1
#endif
#if(A_SEGMENT_NA_PORCIE==B || B_SEGMENT_NA_PORCIE==B || C_SEGMENT_NA_PORCIE==B || D_SEGMENT_NA_PORCIE==B || E_SEGMENT_NA_PORCIE==B || F_SEGMENT_NA_PORCIE==B ||G_SEGMENT_NA_PORCIE==B || H_SEGMENT_NA_PORCIE==B )
#define SEGMENTY_NA_PORCIE_B 1
#endif
#if(A_SEGMENT_NA_PORCIE==C || B_SEGMENT_NA_PORCIE==C || C_SEGMENT_NA_PORCIE==C || D_SEGMENT_NA_PORCIE==C || E_SEGMENT_NA_PORCIE==C || F_SEGMENT_NA_PORCIE==C ||G_SEGMENT_NA_PORCIE==C || H_SEGMENT_NA_PORCIE==C )
#define SEGMENTY_NA_PORCIE_C 1
#endif
#if(A_SEGMENT_NA_PORCIE==D || B_SEGMENT_NA_PORCIE==D || C_SEGMENT_NA_PORCIE==D || D_SEGMENT_NA_PORCIE==D || E_SEGMENT_NA_PORCIE==D || F_SEGMENT_NA_PORCIE==D ||G_SEGMENT_NA_PORCIE==D || H_SEGMENT_NA_PORCIE==D )
#define SEGMENTY_NA_PORCIE_D 1
#endif

/******************************************************************************************************************************
*
* DEFINICJE ZAŁĄCZANIA WSPÓLNYCH ANOD-KATOD
*
* *****************************************************************************************************************************/

#if ZALACZANIE_CYFERBLATOW//************* DEFINICJE ZAŁĄCZANIA STANEM WYSOKIM*************

#if (LICZBA_CYFERBLATOW==1)// DLA JEDNEJ CYFRY

#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#endif
#if (LICZBA_CYFERBLATOW==2)// DLA DWÓCH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 |= CYFERBLAT_2
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1; PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#endif
#if (LICZBA_CYFERBLATOW==3)// DLA TRZECH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 |= CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 |= CYFERBLAT_3
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1; PORT_CYFERBLAT_2 &= ~CYFERBLAT_2; PORT_CYFERBLAT_3 &= ~CYFERBLAT_3
#endif
#if (LICZBA_CYFERBLATOW==4)// DLA CZTERECH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 |= CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 |= CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 |= CYFERBLAT_4
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1; PORT_CYFERBLAT_2 &= ~CYFERBLAT_2; PORT_CYFERBLAT_3 &= ~CYFERBLAT_3; PORT_CYFERBLAT_4 &= ~CYFERBLAT_4
#endif
#if (LICZBA_CYFERBLATOW==5)// DLA PIĘCIU CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 |= CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 |= CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 |= CYFERBLAT_4
#define CYFERBLAT_5_ON PORT_CYFERBLAT_5 |= CYFERBLAT_5
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1; PORT_CYFERBLAT_2 &= ~CYFERBLAT_2; PORT_CYFERBLAT_3 &= ~CYFERBLAT_3; PORT_CYFERBLAT_4 &= ~CYFERBLAT_4; PORT_CYFERBLAT_5 &= ~CYFERBLAT_5
#endif
#if (LICZBA_CYFERBLATOW==6)// DLA SZEŚCIU CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 |= CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 |= CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 |= CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 |= CYFERBLAT_4
#define CYFERBLAT_5_ON PORT_CYFERBLAT_5 |= CYFERBLAT_5
#define CYFERBLAT_6_ON PORT_CYFERBLAT_6 |= CYFERBLAT_6
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 &= ~CYFERBLAT_1; PORT_CYFERBLAT_2 &= ~CYFERBLAT_2; PORT_CYFERBLAT_3 &= ~CYFERBLAT_3; PORT_CYFERBLAT_4 &= ~CYFERBLAT_4; PORT_CYFERBLAT_5 &= ~CYFERBLAT_5; PORT_CYFERBLAT_6 &= ~CYFERBLAT_6

#endif

#else//*************DEFINICJE ZAŁĄCZANIA STANEM NISKIM*******************

#if (LICZBA_CYFERBLATOW==1)// DLA JEDNEJ CYFRY

#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~(CYFERBLAT_1)
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= CYFERBLAT_1
#endif

#if (LICZBA_CYFERBLATOW==2)// DLA DWÓCH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= CYFERBLAT_1; PORT_CYFERBLAT_2 |= CYFERBLAT_2

#endif

#if (LICZBA_CYFERBLATOW==3)// DLA TRZECH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 &= ~CYFERBLAT_3
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= CYFERBLAT_1; PORT_CYFERBLAT_2 |= CYFERBLAT_2; PORT_CYFERBLAT_3 |= CYFERBLAT_3
#endif

#if (LICZBA_CYFERBLATOW==4)// DLA CZTERECH CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 &= ~CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 &= ~CYFERBLAT_4
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= CYFERBLAT_1; PORT_CYFERBLAT_2 |= CYFERBLAT_2; PORT_CYFERBLAT_3 |= CYFERBLAT_3; PORT_CYFERBLAT_4 |= CYFERBLAT_4
#endif

#if (LICZBA_CYFERBLATOW==5)// DLA PIĘCIU CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 &= ~CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 &= ~CYFERBLAT_4
#define CYFERBLAT_5_ON PORT_CYFERBLAT_5 &= ~CYFERBLAT_5
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= ANODA_KATODA_1; PORT_CYFERBLAT_2 |= CYFERBLAT_2; PORT_CYFERBLAT_3 |= CYFERBLAT_3; PORT_CYFERBLAT_4 |= CYFERBLAT_4; PORT_CYFERBLAT_5 |= CYFERBLAT_5
#endif

#if (LICZBA_CYFERBLATOW==6)// DLA SZEŚCIU CYFR
#define CYFERBLAT_1_ON PORT_CYFERBLAT_1 &= ~CYFERBLAT_1
#define CYFERBLAT_2_ON PORT_CYFERBLAT_2 &= ~CYFERBLAT_2
#define CYFERBLAT_3_ON PORT_CYFERBLAT_3 &= ~CYFERBLAT_3
#define CYFERBLAT_4_ON PORT_CYFERBLAT_4 &= ~CYFERBLAT_4
#define CYFERBLAT_5_ON PORT_CYFERBLAT_5 &= ~CYFERBLAT_5
#define CYFERBLAT_6_ON PORT_CYFERBLAT_6 &= ~CYFERBLAT_6
#define WYGAS_CYFERBLATY PORT_CYFERBLAT_1 |= CYFERBLAT_1; PORT_CYFERBLAT_2 |= CYFERBLAT_2; PORT_CYFERBLAT_3 |= CYFERBLAT_3; PORT_CYFERBLAT_4 |= CYFERBLAT_4; PORT_CYFERBLAT_5 |= CYFERBLAT_5; PORT_CYFERBLAT_6 |= CYFERBLAT_6
#endif

#endif

/*******************************************************************************************************************************
*
* DEFINICJE WYSWIETLANIA SEGMENTÓW-CYFR NA RÓŻNYCH PINACH I PORTACH
*
******************************************************************************************************************************/

#if ZALACZANIE_SEGMENTOW

// DEFINICJE ZAŁĄCZANA SEGMENTóW STANEM WYSOKIM
#define CYFRA_0 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT;PORT_C_SEGMENT |= C_SEGMENT;PORT_D_SEGMENT |= D_SEGMENT; PORT_E_SEGMENT |= E_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT
#define CYFRA_1 PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT
#define CYFRA_2 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT;PORT_G_SEGMENT |= G_SEGMENT; PORT_E_SEGMENT |= E_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT
#define CYFRA_3 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT
#define CYFRA_4 PORT_F_SEGMENT |= F_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT
#define CYFRA_5 PORT_A_SEGMENT |= A_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT
#define CYFRA_6 PORT_A_SEGMENT |= A_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT; PORT_E_SEGMENT |= E_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT
#define CYFRA_7 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT;
#define CYFRA_8 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT; PORT_E_SEGMENT |= E_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT
#define CYFRA_9 PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT
#define KROPKAPORT_H_SEGMENT |= H_SEGMENT
#define KROPKA_TOGPORT_H_SEGMENT ^= H_SEGMENT

#define WYGAS_SEGMENTY PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_H_SEGMENT &= ~H_SEGMENT

#else// DEFINICJE ZAŁĄCZANA SEGMENTóW STANEM NISKIM
#define CYFRA_0PORT_A_SEGMENT &= ~A_SEGMENT;PORT_B_SEGMENT &= ~B_SEGMENT;PORT_C_SEGMENT &= ~C_SEGMENT;PORT_D_SEGMENT &= ~D_SEGMENT;PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT
#define CYFRA_1PORT_B_SEGMENT &= ~B_SEGMENT;PORT_C_SEGMENT &= ~C_SEGMENT
#define CYFRA_2PORT_A_SEGMENT &= ~A_SEGMENT;PORT_B_SEGMENT &= ~B_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT
#define CYFRA_3PORT_A_SEGMENT &= ~A_SEGMENT;PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT
#define CYFRA_4PORT_F_SEGMENT &= ~F_SEGMENT;PORT_G_SEGMENT &= ~G_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT
#define CYFRA_5PORT_A_SEGMENT &= ~A_SEGMENT;PORT_F_SEGMENT &= ~F_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT
#define CYFRA_6PORT_A_SEGMENT &= ~A_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT
#define CYFRA_7PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT;
#define CYFRA_8PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT
#define CYFRA_9PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT
#define KROPKAPORT_H_SEGMENT &= ~H_SEGMENT
#define KROPKA_TOGPORT_H_SEGMENT ^= H_SEGMENT

#define WYGAS_SEGMENTY PORT_A_SEGMENT |= A_SEGMENT; PORT_B_SEGMENT |= B_SEGMENT; PORT_C_SEGMENT |= C_SEGMENT; PORT_D_SEGMENT |= D_SEGMENT; PORT_E_SEGMENT |= E_SEGMENT; PORT_F_SEGMENT |= F_SEGMENT; PORT_G_SEGMENT |= G_SEGMENT; PORT_H_SEGMENT |= H_SEGMENT

#endif

/*******************************************************************************************************************************
*
* ********************** POWOLANIE ZMIENNYCH
*
* ****************************************************************************************************************************/

volatile uint8_t

#if LICZBA_CYFERBLATOW>5
szosta,
#endif
#if LICZBA_CYFERBLATOW>4
piata,
#endif
#if LICZBA_CYFERBLATOW>3
czwarta,
#endif
#if LICZBA_CYFERBLATOW>2
trzecia,
#endif
#if LICZBA_CYFERBLATOW>1
druga,
#endif
pierwsza,
#endif

flag_sek, sek, god, min;

//*****************************************************************************************************************************

/* MAIN */

// ****************************************************************************************************************************

int main(void) {

#if LICZBA_CYFERBLATOW

/*---------------------------------------------------------

INICJALIZACJA WYSWIETLACZA

---------------------------------------------------*/

/*----WYJSCIA NA CYFERBLATY----*/

DDR_CYFERBLAT_1 |= CYFERBLAT_1;
#endif
#if LICZBA_CYFERBLATOW>1
DDR_CYFERBLAT_2 |= CYFERBLAT_2;
#endif
#if LICZBA_CYFERBLATOW>2
DDR_CYFERBLAT_3 |= CYFERBLAT_3;
#endif
#if LICZBA_CYFERBLATOW>3
DDR_CYFERBLAT_4 |= CYFERBLAT_4;
#endif
#if LICZBA_CYFERBLATOW>4
DDR_CYFERBLAT_5 |= CYFERBLAT_5;
#endif
#if LICZBA_CYFERBLATOW>5
DDR_CYFERBLAT_6 |= CYFERBLAT_6;
#endif

#if LICZBA_CYFERBLATOW

/*----WYJŚCIA SEGMENTÓW LED-----*/

DDR_A_SEGMENT |= A_SEGMENT;
DDR_B_SEGMENT |= B_SEGMENT;
DDR_C_SEGMENT |= C_SEGMENT;
DDR_D_SEGMENT |= D_SEGMENT;
DDR_E_SEGMENT |= E_SEGMENT;
DDR_F_SEGMENT |= F_SEGMENT;
DDR_G_SEGMENT |= G_SEGMENT;
DDR_H_SEGMENT |= H_SEGMENT;
#endif

/*----USTAWIENIA TIMERA---------*/

TCCR0 |= (1 << CS00) | (1 << CS01); /* preskaler = 256*/
TIMSK |= (1 << TOIE0);/* zezwolenie na przerwanie od przepelnienia*/
sei();/* globalne zezwolenie na przerwania*/

//************************************************************************************

/* PĘTLA GŁÓWNA */

//************************************************************************************
while (1) {

if (flag_sek)
{
flag_sek = 0;
if (sek < 59) {sek++;}
else {
sek = 0;
if (min < 59) {min++;}
else {
min = 0;
if (god < 24) {god++;}
else {god = 0;}
}
}
}

/*----WARTOŚCI DO WYŚWIETLENIA NA LED----*/

#if LICZBA_CYFERBLATOW// jeżeli liczba cyfr na wyswietlaczu > 0

pierwsza = (sek % 10);// pierwsza cyfra
#endif
#if LICZBA_CYFERBLATOW>1// jeżeli liczba cyfr na wyswietlaczu > 1
druga = sek / 10;// druga cyfra
#endif
#if LICZBA_CYFERBLATOW>2// jeżeli liczba cyfr na wyswietlaczu > 2
trzecia = (min % 10);
#endif
#if LICZBA_CYFERBLATOW>3// jeżeli liczba cyfr na wyswietlaczu > 3
czwarta = min / 10;
#endif
#if LICZBA_CYFERBLATOW>4// jeżeli liczba cyfr na wyswietlaczu > 4
piata = (god % 10);
#endif
#if LICZBA_CYFERBLATOW>5// jeżeli liczba cyfr na wyswietlaczu > 5
szosta = god / 10;
#endif

} // KONIEC PETLI GLOWNEJ*********************************************************

} // KONIEC MAIN**********************************************************************

//************************************************************************************

/* PRZERWANIE */

// ***********************************************************************************
ISR(TIMER0_OVF_vect) { /*przerwanie 500 razy na sekundę*/

TCNT0 = 5;/* <---- timer zlicza od tej wartości - do 255- */
/* wywołuje to przerwanie i znowu zaczyna od tej wartości*/
/*czyli oscylator-8MHz / preskaler-64 / licznik zlicza 250=255-5 / jeszcze nasze "zliczanie"-0--499->500 = 1 Hz :) */

static uint16_t zliczanie = 0; // licznik przerwań

if (zliczanie)// ta zmienne jest dekrementowana 500 razy na sekunde,
{
zliczanie--;
}
else
{ // wiec co sekunde osiaga 0 i trzeba znowu wpisac do niej 499
zliczanie = 499;
flag_sek++;// inkrementowanie flagi co sekundę . Można wpisywac 1 - (Ja inkrementuję bo gdy niechcący jakąś kocią funkcją - np. do obsługi klawiszy zablokuję pętlę na dłużej niż 2 wywołania flagi, to po odblokowaniu zsumuje ilośc pominiętch i doda kilka sekund)
}

#if LICZBA_CYFERBLATOW

static uint8_t kolejny_cyferblat;// 1 > 2(jeżeli załączona) > 3(jeżeli załączona) > 4(jeżeli załączona) > 5(jeżeli załączona) > 6(jeżeli załączona)

kolejny_cyferblat++;// w następnym przerwaniu nastepna cyfra
if (kolejny_cyferblat > LICZBA_CYFERBLATOW)// zliczanie do określonej ilości cyfr do wyświetlenia-( gdy wyświetlacz z dwoma cyframi to gdy jest więcej niż 2, powróci do 1 .
kolejny_cyferblat = 1;// ponownie pierwsza cyfra na wyświetlaczu.

//----GASZENIE WYSWIETLACZA----
WYGAS_CYFERBLATY
;
WYGAS_SEGMENTY
;

//----WYSWIETLANIE CYFR NA CYFERBLATACH ;)

if (kolejny_cyferblat == 1) {// gdy czas na pierwsza cyfre -

CYFERBLAT_1_ON;// zalacz pierwsza anode-katode

if (pierwsza == 0) {CYFRA_0;}// gdy pierwsza cyfra jest 0 // zalacz segmenty dla cyfry 0
else if (pierwsza == 1) {CYFRA_1;}
else if (pierwsza == 2) {CYFRA_2;}
else if (pierwsza == 3) {CYFRA_3;}
else if (pierwsza == 4) {CYFRA_4;}
else if (pierwsza == 5) {CYFRA_5;}
else if (pierwsza == 6) {CYFRA_6;}
else if (pierwsza == 7) {CYFRA_7;}
else if (pierwsza == 8) {CYFRA_8;}
else if (pierwsza == 9) {CYFRA_9;}
}

#endif

#if LICZBA_CYFERBLATOW >1
else if (kolejny_cyferblat == 2) {

CYFERBLAT_2_ON;

if (druga == 0){CYFRA_0;}
else if (druga == 1) {CYFRA_1;}
else if (druga == 2) {CYFRA_2;}
else if (druga == 3) {CYFRA_3;}
else if (druga == 4) {CYFRA_4;}
else if (druga == 5) {CYFRA_5;}
else if (druga == 6) {CYFRA_6;}
else if (druga == 7) {CYFRA_7;}
else if (druga == 8) {CYFRA_8;}
else if (druga == 9) {CYFRA_9;}
}
#endif

#if LICZBA_CYFERBLATOW >2
else if (kolejny_cyferblat == 3) {

if (sek % 2 == 1) {KROPKA_TOG;}// <---mryganie kropka co 2 sek

CYFERBLAT_3_ON;

if (trzecia == 0) {CYFRA_0;}
else if (trzecia == 1) {CYFRA_1;}
else if (trzecia == 2) {CYFRA_2;}
else if (trzecia == 3) {CYFRA_3;}
else if (trzecia == 4) {CYFRA_4;}
else if (trzecia == 5) {CYFRA_5;}
else if (trzecia == 6) {CYFRA_6;}
else if (trzecia == 7) {CYFRA_7;}
else if (trzecia == 8) {CYFRA_8;}
else if (trzecia == 9) {CYFRA_9;}
}
#endif

#if LICZBA_CYFERBLATOW >3
else if (kolejny_cyferblat == 4) {

CYFERBLAT_4_ON;

if (czwarta == 0) {CYFRA_0;}
else if (czwarta == 1) {CYFRA_1;}
else if (czwarta == 2) {CYFRA_2;}
else if (czwarta == 3) {CYFRA_3;}
else if (czwarta == 4) {CYFRA_4;}
else if (czwarta == 5) {CYFRA_5;}
else if (czwarta == 6) {CYFRA_6;}
else if (czwarta == 7) {CYFRA_7;}
else if (czwarta == 8) {CYFRA_8;}
else if (czwarta == 9) {CYFRA_9;}
}
#endif

#if LICZBA_CYFERBLATOW >4
else if (kolejny_cyferblat == 5) {
CYFERBLAT_5_ON;

if (piata == 0) {CYFRA_0;}
else if (piata == 1) {CYFRA_1;}
else if (piata == 2) {CYFRA_2;}
else if (piata == 3) {CYFRA_3;}
else if (piata == 4) {CYFRA_4;}
else if (piata == 5) {CYFRA_5;}
else if (piata == 6) {CYFRA_6;}
else if (piata == 7) {CYFRA_7;}
else if (piata == 8) {CYFRA_8;}
else if (piata == 9) {CYFRA_9;}
}
#endif

#if LICZBA_CYFERBLATOW >5
else if (kolejny_cyferblat == 6) {
CYFERBLAT_6_ON;

if (sek % 4 == 1) {KROPKA_TOG;}

if (szosta == 0) {CYFRA_0;}
else if (szosta == 1) {CYFRA_1;}
else if (szosta == 2) {CYFRA_2;}
else if (szosta == 3) {CYFRA_3;}
else if (szosta == 4) {CYFRA_4;}
else if (szosta == 5) {CYFRA_5;}
else if (szosta == 6) {CYFRA_6;}
else if (szosta == 7) {CYFRA_7;}
else if (szosta == 8) {CYFRA_8;}
else if (szosta == 9) {CYFRA_9;}
}
#endif

} // KONIEC PRZERWANIA[/syntax]

Pozdrawiam i miłej rozkminki.
Tylko nie obsmarujcie mnie za mocno.

Statystyki: Napisane przez Daro69 — 16 wrz 2016, o 17:44

Re: wyświetlacz fluorescencyjny

2016-09-16T16:07:24+01:00

Witam "Harry",
Tu się chyba nie zrozumieliśmy.
Ja próbowałem umieścić w tablicy dziewięć elementów.
Problem był w tym że nie potrafię umieścić w tablicy całych dyrektyw zawierających nazwy portów i pinów tak by potem je wykorzystać przy odczycie.
np.
pierwszym elementem musiałoby być takie makro w całości bo to jest reprezentacja cyfry "0" na wyświetlaczu:
[syntax=c]PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT[/syntax]
Gdyby nawet ten jeden element tablicy rozbić na poszczególne polecenia, - no właśnie - polecenia a nie zmienne
to i tak jest problem bo jak w tablicy używać poleceń - i jak potem wypchnąć z tablicy do pętli taki jej element?
.np. "PORTD &=~(1<PORTU.

int tab[0]={PORTD &=~(1<
jeżeli teraz w programie spróbuje wywołać taki element tablicy- to niby jak.?
[syntax=c]tab[0]; // ?

cyfra = tab[0]; // ?
cyfra;

napis = tab[0]; // ?
napis;[/syntax]
gdyby nawet to jeszcze bardziej rozdzielić,
[syntax=c]char tab[]={"PORTD","|=(1<<3)"};[/syntax]
to i tak nie zadziała wywołanie w pętli bo jak?
[syntax=c]tab[0];tab[1]; // ??[/syntax]
nie podmieni się na polecenia.

To nie zadziała, podobnie jak próby sklejania PORT z literą np. B - nie wykorzystując do tego celu makr upraszczających.
Jeżeli czegoś tu nie wiem to bardzo chętnie się nauczę. Możliwe że są jakieś sposoby.

A może o czymś innym piszemy.

Statystyki: Napisane przez Daro69 — 16 wrz 2016, o 16:07

Re: wyświetlacz fluorescencyjny

2016-09-16T11:01:01+01:00

Daro69 napisał(a):

Harry napisał(a):
A niby czemu nie? Przecież tablice są indexowane właśnie od zera.

No tak, ale ja w tym nowszym kodzie mam takie coś w definicjach, a one zawierają wpisy np.: PORTD &=~(1<[syntax=c]#define CYFRA_0 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT
#define CYFRA_1 PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT
#define CYFRA_2 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT[/syntax]
jak to wkitrać w tablicę ? muszę coś innego kurcze wykombinować.

------------------------ [ Dodano po: 17 minutach ]

Ogólnie mówiąc próbujemy tak napisać program żeby można było dowolnie konfigurować każdy PIN wyświetlacza. np katoda segment A będzie na PD0 a segment B na PB1 ? a anody np 4, też w różnych miejscach - nie koniecznie na jednym porcie 0,1,2,3 .

Przecież dla preprocesora to bez różnicy, kompilator i tak zamieni tak jak powinno być, równie dobrze mógłbyś to napisać tak:

[syntax=c]#define CYFRA_0 (1<#define STALA_NR_1 CYFRA 0
#define STALA_NR_2 STALA_NR_1
#define STALA_NR_3 STALA_NR_2
#define STALA_NR_4 STALA_NR_3[/syntax]

Statystyki: Napisane przez Harry — 16 wrz 2016, o 11:01

Re: wyświetlacz fluorescencyjny

2016-09-16T00:34:50+01:00

Hejka,
Wojtku, ta nowsza wersja V.2 czeka na Ciebie, od wczoraj.
Myślę jednak że w celach edukacyjnych,
znacznie łatwiejszy do zrozumienia i załapania zasady działania wyświetlacza LED jest ten pierwszy program V.1 ,
z anodami na jednym porcie i katodami też na jednym porcie w kolejności od 0.

Gdyby się okazało że już wiesz o co chodzi to zrobimy kilka kroków do przodu bo wstawię tu - LED_V2.
Co prawda kod pozostawia jeszcze wiele do życzenia, bo muszę się sporo nauczyć i wprawić w konstruowaniu algorytmów.
Nie mniej jednak działa.
Można w nim dowolnie wybierać piny i porty A, B, C, D, oraz ilość cyferblatów (cyfr na wyświetlaczu) tzn. do 6-ciu,
a także ustawiać czy wysterowanie jest stanem niskim czy wysokim zarówno segmentów jak i wspólnych anod-katod.
Łatwo będzie dostosować do np. tranzystorów sterujących PNP lub NPN, gdyby zaszła potrzeba wzmocnienia wyjścia.

A ja biorę się za pisanie V.3, bo w V.2 jest np. zbyt wiele operacji w przerwaniu i mi się to nie podoba.
Wypadałoby także pouczyć się optymalizacji, a to już nie będzie takie chop-siup.
Zobaczę co mi z tego wyjdzie.

Pozdrawiam Darek.

Statystyki: Napisane przez Daro69 — 16 wrz 2016, o 00:34

Re: wyświetlacz fluorescencyjny

2016-09-11T22:36:44+01:00

Wojtku,
Coś jeszcze... ja podłączyłem pod anody wyświetlacza uc. więc załączam je stanem wysokim.
A u Ciebie jeżeli jest sterowanie przez PNP to musisz stanem niskim załączać, a wysokim wyłączać.
TEN WPIS :
[syntax=c]#define A_1_ON PORT_ANODY |= ANODA_1
#define A_2_ON PORT_ANODY |= ANODA_2
#define A_3_ON PORT_ANODY |= ANODA_3
#define A_4_ON PORT_ANODY |= ANODA_4

#define WYGAS_ANODY PORT_ANODY &=~(ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4)[/syntax]
ZAMIEŃ NA :
[syntax=c]#define A_1_ON PORT_ANODY &=~ ANODA_1
#define A_2_ON PORT_ANODY &=~ ANODA_2
#define A_3_ON PORT_ANODY &=~ ANODA_3
#define A_4_ON PORT_ANODY &=~ ANODA_4

#define WYGAS_ANODY PORT_ANODY |= ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4[/syntax]
możliwe że dlatego nic nie świeciło.
A ja pomyślę nad tym nowszym kodem, -bo już zauważyłem w nim przeoczenia.

------------------------ [ Dodano po: 10 minutach ]

Harry napisał(a):

A niby czemu nie? Przecież tablice są indexowane właśnie od zera.

No tak, ale ja w tym nowszym kodzie mam takie coś w definicjach, a one zawierają wpisy np.: PORTD &=~(1<[syntax=c]#define CYFRA_0 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT
#define CYFRA_1 PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT
#define CYFRA_2 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT[/syntax]
jak to wkitrać w tablicę ? muszę coś innego kurcze wykombinować.

------------------------ [ Dodano po: 17 minutach ]

Ogólnie mówiąc próbujemy tak napisać program żeby można było dowolnie konfigurować każdy PIN wyświetlacza. np katoda segment A będzie na PD0 a segment B na PB1 ? a anody np 4, też w różnych miejscach - nie koniecznie na jednym porcie 0,1,2,3 .

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 22:36

Re: wyświetlacz fluorescencyjny

2016-09-11T22:30:24+01:00

Daro69 napisał(a):

Sam jeszcze nie wiem jak bym to dalej rozpisał, ale w tablicę to już CYFRA_0 nie dam rady wkitrać.

A niby czemu nie? Przecież tablice są indexowane właśnie od zera.

Statystyki: Napisane przez Harry — 11 wrz 2016, o 22:30

Re: wyświetlacz fluorescencyjny

2016-09-11T21:26:19+01:00

Zauważ że te czarne - to są zakomentowane. Po prostu jeszcze z nimi nic nie zrobiłem.
Tak skopiowałem kawałek kodu do wglądu razem z kawałkiem nie przerobionym.
I się zatrzymałem bo się zastanawiam czy dobrą drogę obrałem. Obawiam się że w ten sposób zasypie kod zapisami,
i stanę na rozdrożu. Z tą możliwością wyboru pojedynczych pinów w ustawieniach.
W definicjach PINÓW...anodz jest ich u mnie sześć, bo myślałem o wyświetlaniu także sekund.
Czyli godziny, minuty, sekundy.
Na razie zegarek zamiast pokazywać sekundy - mryga kropką.

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 21:26

Re: wyświetlacz fluorescencyjny

2016-09-11T20:50:34+01:00

Dlaczego część kodu w DEFINICJJACH WYSWIETLANIA CYFR NA RÓŻNYCH PINACH I PORTACH jest na czarno , a część na zielono? tam jest jakiś błąd?? po takim kodzie, to łatwo można przyswoić nowe wiadomości.

------------------------ [ Dodano po: 3 minutach ]

Nie za dużo tych definicji zrobiłeś (DEFINICJE PINOW PORTOW I DDROW Z ANODAMI)? dlaczego sześć pozycji, a nie cztery? bierzesz pod uwagę większy wyświetlacz?

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 20:50

Re: wyświetlacz fluorescencyjny

2016-09-11T19:15:48+01:00

wojciechgorzolka napisał(a):

jeszcze raz się za to wezmę od podstaw, czyli lutowanko

To dobrze bo zobacz co zacząłem pisać, i ile tego greźmolenia się robi.
[syntax=c]#include
#include
#include
/**************************************************
*
* DEFINICJE PINOW PORTOW I DDROW Z ANODAMI
*
**************************************************/
#define ANODA_1 (1<#define PORT_A_1 PORTB
#define DDR_A_1 DDRB

#define ANODA_2 (1<#define PORT_A_2 PORTD
#define DDR_A_2 DDRD

#define ANODA_3 (1<#define PORT_A_3 PORTD
#define DDR_A_3 DDRD

#define ANODA_4 (1<#define PORT_A_4 PORTD
#define DDR_A_4 DDRD

#define ANODA_5 (1<#define PORT_A_5 PORTD
#define DDR_A_5 DDRD

#define ANODA_6 (1<#define PORT_A_6 PORTD
#define DDR_A_6 DDRD
/*************************************************
*
* DEFINICJE PORTÓW Z KATODAMI
*
* ************************************************/

#define DDR_KATODY DDRC
#define PORT_KATODY PORTC

/*************************************************
*
* DEFINICJE ZAŁĄCZANIA ANOD
*
* ************************************************/

#define A_1_ON PORT_A_1 |= ANODA_1
#define A_2_ON PORT_A_2 |= ANODA_2
#define A_3_ON PORT_A_3 |= ANODA_3
#define A_4_ON PORT_A_4 |= ANODA_4
#define A_5_ON PORT_A_5 |= ANODA_5
#define A_6_ON PORT_A_6 |= ANODA_6

#define WYGAS_ANODY PORT_A_1 &= ~ANODA_1; PORT_A_2 &= ~ANODA_2; PORT_A_3 &= ~ANODA_3; PORT_A_4 &= ~ANODA_4; PORT_A_5 &= ~ANODA_5; PORT_A_6 &= ~ANODA_6

/*************************************************
*
* DEFINICJE PINOW I PORTÓW Z SEGMENTAMI
*
* ************************************************/

#define A_SEGMENT (1<#define B_SEGMENT (1<#define C_SEGMENT (1<#define D_SEGMENT (1<#define E_SEGMENT (1<#define F_SEGMENT (1<#define G_SEGMENT (1<#define H_SEGMENT (1<
#define PORT_A_SEGMENT PORTD
#define PORT_B_SEGMENT PORTD
#define PORT_C_SEGMENT PORTD
#define PORT_D_SEGMENT PORTD
#define PORT_E_SEGMENT PORTD
#define PORT_F_SEGMENT PORTD
#define PORT_G_SEGMENT PORTD
#define PORT_H_SEGMENT PORTD

/*************************************************
*
* DEFINICJE WYSWIETLANIA CYFR NA RÓŻNYCH PINACH I PORTACH
*
* ************************************************/

#define CYFRA_0 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_F_SEGMENT &= ~F_SEGMENT
#define CYFRA_1 PORT_B_SEGMENT &= ~B_SEGMENT; PORT_C_SEGMENT &= ~C_SEGMENT
#define CYFRA_2 PORT_A_SEGMENT &= ~A_SEGMENT; PORT_B_SEGMENT &= ~B_SEGMENT; PORT_G_SEGMENT &= ~G_SEGMENT; PORT_E_SEGMENT &= ~E_SEGMENT; PORT_D_SEGMENT &= ~D_SEGMENT
//#define CYFRA_3 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | G_SEGMENT)
//#define CYFRA_4 (F_SEGMENT | G_SEGMENT | B_SEGMENT | C_SEGMENT)
//#define CYFRA_5 (A_SEGMENT | F_SEGMENT | G_SEGMENT | C_SEGMENT | D_SEGMENT)
//#define CYFRA_6 (A_SEGMENT | F_SEGMENT | E_SEGMENT | D_SEGMENT | C_SEGMENT | G_SEGMENT)
//#define CYFRA_7 (A_SEGMENT | B_SEGMENT | C_SEGMENT)
//#define CYFRA_8 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT | G_SEGMENT)
//#define CYFRA_9 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | F_SEGMENT | G_SEGMENT)
//#define CZYSC |=(A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT | G_SEGMENT)

//uint8_t tab[] =
//{
//CYFRA_0,
//CYFRA_1,[/syntax]
Sam jeszcze nie wiem jak bym to dalej rozpisał, ale w tablicę to już CYFRA_0 nie dam rady wkitrać.
Pewnie kombinował bym coś z tym zrobić. Albo zmienić podejście - inny algorytm.
Dlatego dużo łatwiej jest ogarnąć to na jednym porcie ANODY a na innym katody.
Pozdrawiam Darek.

------------------------ [ Dodano po: 14 minutach ]

odnoszę wrażenie że zaczynam błądzić.

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 19:15

Re: wyświetlacz fluorescencyjny

2016-09-11T18:09:34+01:00

no widzisz, wychodzi moje niedoświadczenie. dziękuję za kod w prywatnej wiadomości. jeszcze raz się za to wezmę od podstaw, czyli lutowanko

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 18:09

Re: wyświetlacz fluorescencyjny

2016-09-11T17:28:23+01:00

Dobrze jest najpierw rozplanować i przemyśleć które piny do czego będą, bo potem mogą być konflikty gdy się okaże że płytka zlutowana, wykorzystany port B, a trzeba dać zewnętrzny kwarc na PB6 i PB7.

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 17:28

Re: wyświetlacz fluorescencyjny

2016-09-11T15:45:11+01:00

to prawda. podłączyłem ten mój układ, jak na razie tylko z jednym tranzystorem i po wgraniu Twojego kodu niestety cisza, nie działa. coś chyba źle polutowałem

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 15:45

Re: wyświetlacz fluorescencyjny

2016-09-11T15:36:24+01:00

NIE.

------------------------ [ Dodano po: 3 minutach ]

Bo producent nie przewiduje jakim napięciem je zasilisz, więc produkuje bez, z gołymi ledami i trzeba samemu je dopasować do własnych potrzeb. Bo co by było gdyby jeden projekt przewidywał 5V a inny 3.5V.- wydłubywać ?

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 15:36

Re: wyświetlacz fluorescencyjny

2016-09-11T15:30:40+01:00

rezystory powinny być w mojej obudowie już fabrycznie zamontowane?

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 15:30

Re: wyświetlacz fluorescencyjny

2016-09-11T14:23:43+01:00

dlatego w próbnym programiku zasugerowałem 8 katod na D, i 4 anody na C.
Pomyślałem że przyda się wolne PB6 i PB7 na dokładniejszy stabilniejszy i szybszy ewentualny kwarc

------------------------ [ Dodano po: 1 minucie ]

A zegarek już sobie tyka. TYK... TYK...TYK... ....

edit.........
co do rezystorów to na ~99,9% przypadków, powinny być

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 14:23

Re: wyświetlacz fluorescencyjny

2016-09-11T14:06:14+01:00

tak, osiem, ponieważ to są rezystory które idą do diod segmentów. chyba tam muszą być , bo w wyświetlaczu ich chyba nie ma , no chyba ,że są w obudowie i nie wziąłem tego pod uwagę
w sumie to mogłem to zrobić na całym porcie B

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 14:06

Re: wyświetlacz fluorescencyjny

2016-09-11T12:44:29+01:00

Da się.

------------------------ [ Dodano po: 5 minutach ]

Na czas programowania trzeba odpiąć te trzy kabelki wyświetlacza z mosi miso sck, albo zabezpieczyć żeby żeby nie zakłócały swoim obciążeniem wejść/wyjść programatora.

------------------------ [ Dodano po: 13 minutach ]

a, .. i przede wszystkim od programatora wpinaj prosto w nogi nie za rezystorami czasem.

------------------------ [ Dodano po: 18 minutach ]

Troszkę sobie utrudniasz jak na początek,
bo osiem rezystorów widzę : PB1, PB2, PB3, PB4, PB5,.....PC0, PC1, PC2.

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 12:44

Re: wyświetlacz fluorescencyjny

2016-09-11T11:47:34+01:00

No tak. a Czy to znaczy ,że tych pinów nie mogę używać do wyświetlacza?

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 11:47

Re: wyświetlacz fluorescencyjny

2016-09-11T11:44:43+01:00

cześc,
chyba jest mały problem
podłączyłeś rezystory do zasilania ledziaka na pinach PB3, PB4, PB5 to przecież w ATmega8 jest MOSI MISO CSK.

Statystyki: Napisane przez Daro69 — 11 wrz 2016, o 11:44

Re: wyświetlacz fluorescencyjny

2016-09-11T10:15:20+01:00

Układ do nauki multipleksowania prawie gotowy, jeszcze tylko muszę dolutować jeden segment i będzie cacunia
Zastanawia mnie jedna rzecz, nie wiem czy czegoś źle nie polutowałem, bo gdy chcę zaprogramować atmegę8, to mogę to zrobić gdy wyświetlacz nie jest podłączony wspólną katodą do pinu numer 22 czyli GND. podczas wgrywania wsadu wyskakuje komunikat rc=-1, a gdy ten pin nie jest podłączony , to zaprogramować się da. jest na to jakiś sposób?

zaraz zaczynam zabawę

Statystyki: Napisane przez wojciechgorzolka — 11 wrz 2016, o 10:15

Re: wyświetlacz fluorescencyjny

2016-09-10T11:38:24+01:00

mam jeszcze pytanie. Oglądałem poradnik z rtc-ds3231. i chciałbym się upewnić,że cały wsad programu z poradnika jest w atmedze, tak? a ten mały scalaczek ds3231 jest tylko konfigurowany?

Statystyki: Napisane przez wojciechgorzolka — 10 wrz 2016, o 11:38

Re: wyświetlacz fluorescencyjny

2016-09-10T11:23:54+01:00

OK,Poczekam .
Przygotowałem cd bo w tygodniu mogę mieć krucho z czasem.
U mnie już wyświetlają się godziny i minuty.
Ale tak jak pisałem te kody to tak raczej poglądowo co jak mniej więcej działa, mimo że są sprawne.
Od tego robala nabawiłem się chyba kompleksów, no i muszę coś z tym zrobić.
chyba wiem, zaleję go sokiem.
A potem zabiorę się za analizowanie każdego z osobna pod lupą.

Statystyki: Napisane przez Daro69 — 10 wrz 2016, o 11:23

Re: wyświetlacz fluorescencyjny

2016-09-10T09:17:46+01:00

Darku , dzięki za kody, właśnie je przyswajam, póki co nie podawaj więcej, ponieważ najpierw te muszę ogarnąć. Wczoraj lutowałem układ z Atmegą8 na płytce z segmentami i dzisiaj skupię się na zajęciach praktycznych. Nie posiadam ATB, tak więc lutuję na płytce uniwersalenj.
Z góry dziękuję za tak wyczerpujące Twoje zaangażowanie.

Statystyki: Napisane przez wojciechgorzolka — 10 wrz 2016, o 09:17

Re: wyświetlacz fluorescencyjny

2016-09-10T00:49:55+01:00

OK, jestem.
piszemy dalej. No może nie tak jak nasz wzorcowy kolega z łamigłówki z robalem,to było MISTRZOSTWO ŚWIATA,
ale tak żeby może na prostych poleceniach łatwo było zrozumieć co się dzieje.
Jeżeli już znudziło Ci się mruganie wyświetlacza od pierwszego do ostatniego cyferblatu,
a mam nadzieję że tak, to dopiszemy jeszcze kilka linijek.
1) zauważysz w kodzie dodatkowe definicje, - do pinów - z katodami do wyświetlania cyfr.
2) definicje np. "CYFRA_0". to są segmenty-piny które odpowiadają za wyświetlanie segmentów na wyświetlaczu. Są wspólne dla wszystkich cyferblatów. hie.. ale se nazwałem.
3) powołane zmienne : pierwsza, druga, ... to będą wyświetlane cyfry na pierwszej pozycji, drugiej, ...
4) Jest jeszcze coś. ta...bli...ca... do przechowywania i wyciągania z niej segmentów ktore mają się zapalać przy danych cyfrach. zakładam że skoro bawimy się wyświetlaczem to już wiesz co to jest. pewnie tak.

Zamysł jest taki: cyfry które chcemy wyświetlić maja jakąś wartość od 0 do 9.
za pomocą tych wartości będziemy wyświetlać kolejne elementy tablicy.
Czyli: dla zmiennej pierwsza np. = 2, wyświetli się element drugi z tablicy w którym są ukryte wyświetlające się wartości segmentów dla cyfry 2. tab[2] . dla cyfry 0 tab[0].....
oczywiście nie będziemy tu wpisywać cyferek 1, 5, 0, 3.... tylko zmienną, która przyjmując różne wartości będzie wybierała z tablicy kolejne elementy. Gdy będzie miała wartość 4 to wybierze element czwarty.
A oto i moja sieczka.

[syntax=c]#include
#include
#include

#define ANODA_1 (1<#define ANODA_2 (1<#define ANODA_3 (1<#define ANODA_4 (1<
#define DDR_ANODY DDRC
#define PORT_ANODY PORTC

#define DDR_KATODY DDRD
#define PORT_KATODY PORTD

#define A_1_ON PORT_ANODY |= ANODA_1
#define A_2_ON PORT_ANODY |= ANODA_2
#define A_3_ON PORT_ANODY |= ANODA_3
#define A_4_ON PORT_ANODY |= ANODA_4

#define WYGAS_ANODY PORT_ANODY &=~(ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4)

#define A_SEGMENT (1<#define B_SEGMENT (1<#define C_SEGMENT (1<#define D_SEGMENT (1<#define E_SEGMENT (1<#define F_SEGMENT (1<#define G_SEGMENT (1<#define H_SEGMENT (1<
#define CYFRA_0 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT)
#define CYFRA_1 (B_SEGMENT | C_SEGMENT)
#define CYFRA_2 (A_SEGMENT | B_SEGMENT | G_SEGMENT | E_SEGMENT | D_SEGMENT)
#define CYFRA_3 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | G_SEGMENT)
#define CYFRA_4 (F_SEGMENT | G_SEGMENT | B_SEGMENT | C_SEGMENT)
#define CYFRA_5 (A_SEGMENT | F_SEGMENT | G_SEGMENT | C_SEGMENT | D_SEGMENT)
#define CYFRA_6 (A_SEGMENT | F_SEGMENT | E_SEGMENT | D_SEGMENT | C_SEGMENT | G_SEGMENT)
#define CYFRA_7 (A_SEGMENT | B_SEGMENT | C_SEGMENT)
#define CYFRA_8 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT | G_SEGMENT)
#define CYFRA_9 (A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | F_SEGMENT | G_SEGMENT)
#define CZYSC |=(A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT | G_SEGMENT| H_SEGMENT)

uint8_t tab[] =
{
CYFRA_0,
CYFRA_1,
CYFRA_2,
CYFRA_3,
CYFRA_4,
CYFRA_5,
CYFRA_6,
CYFRA_7,
CYFRA_8,
CYFRA_9
};

volatile uint8_t pierwsza;
volatile uint8_t druga;
volatile uint8_t trzecia;
volatile uint8_t czwarta;

int main(void)
{

DDR_ANODY |= ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4;
DDR_KATODY |= A_SEGMENT | B_SEGMENT | C_SEGMENT | D_SEGMENT | E_SEGMENT | F_SEGMENT | G_SEGMENT | H_SEGMENT;

/*ustawienie timer0*/
TCCR0 |= (1 << CS02); /* preskaler = 256*/
TIMSK |= (1 << TOIE0); /* zezwolenie na przerwanie od przepelnienia*/
sei();
/*globalne zezwolenie na przerwania*/

while (1)
{

pierwsza = 0;
druga = 1;
trzecia = 2;
czwarta = 3;

}
}

ISR(TIMER0_OVF_vect)
{ /*przerwanie 125 razy na sekundę*/
TCNT0 = 5; /*timer zlicza od tej wartości - do 255- wywołuje to przerwanie i znowu zaczyna od tej wartości
czyli oscylator-8MHz / preskaler-256 / licznik zlicza 250 / jeszcze nasze "zliczanie"-125 = 1 Hz :) */

static uint8_t zliczanie = 0;
static uint8_t kolejnosc_anod;

kolejnosc_anod++;
if (kolejnosc_anod > 3)
kolejnosc_anod = 0;

if (zliczanie)/*ta zmienne jest dekrementowana 125 razy na sekunde, */
{
zliczanie--;

}
else
{ /*wiec co sekunde osiaga 0 i trzeba znowu wpisac do niej 124*/
zliczanie = 124;

WYGAS_ANODY;
PORT_KATODY CZYSC;
if (kolejnosc_anod == 0)
{
A_1_ON;
PORT_KATODY &= ~tab[pierwsza];
}
else
if (kolejnosc_anod == 1)
{
A_2_ON;
PORT_KATODY &= ~tab[druga];
}
else
if (kolejnosc_anod == 2)
{
A_3_ON;
PORT_KATODY &= ~tab[trzecia];
}
else
if (kolejnosc_anod == 3)
{
A_4_ON;
PORT_KATODY &= ~tab[czwarta];
}
}

}[/syntax]
cdn

Statystyki: Napisane przez Daro69 — 10 wrz 2016, o 00:49

Re: wyświetlacz fluorescencyjny

2016-09-08T23:28:09+01:00

No jestem, jestem.
Trochę późno, ale tak jak obiecałem. np. ATmega8- 8MHz, Timer0, przerwanie OVF.(od przepełnienia- bo to ten najsłabszy timer)
Nie wiem jak Ci idzie multipleksowanie z BB. Czy wszystko jasne, czy próbujesz wykorzystać gotowca z płyty i go ogarnąć.
Coś może ułatwi taki wstęp do zrozumienia multipleksowania.
Specjalnie w zwolnionym tempie 1sek.
Jak sobie podepniesz to pod anody, a na katody dowolne wyswietlacza 7-segm. podasz masę, to już masz sekwencyjne sterowanie anodami.
Jeżeli już coś z tego kojarzysz to lepiej używaj Mirkowego sposobu, bo ja z wiadomych względów nie mogę go tu przedstawić więc napisałem taki zakręcony przykładzik.
Potem w takt zmiany zasilania anod trzeba zmieniać cyfry które mają być wyświetlane.

[syntax=c]#include
#include
#include

#define ANODA_1 (1<#define ANODA_2 (1<#define ANODA_3 (1<#define ANODA_4 (1<
#define DDR_ANODY DDRC
#define PORT_ANODY PORTC

#define A_1_ON PORT_ANODY |= ANODA_1
#define A_2_ON PORT_ANODY |= ANODA_2
#define A_3_ON PORT_ANODY |= ANODA_3
#define A_4_ON PORT_ANODY |= ANODA_4

#define WYGAS_ANODY PORT_ANODY &=~(ANODA_1 | ANODA_2 | ANODA_3 | ANODA_4)

int main(void) {

DDR_ANODY |=ANODA_1|ANODA_2|ANODA_3|ANODA_4;
/*ustawienie timer0*/
TCCR0 |= (1<TIMSK |= (1< sei(); /*globalne zezwolenie na przerwania*/

while(1){

}
}

ISR(TIMER0_OVF_vect)
{ /*przerwanie 125 razy na sekundę*/
TCNT0 = 5; /*timer zlicza od tej wartości - do 255- wywołuje to przerwanie i znowu zaczyna od tej wartości
czyli oscylator-8MHz / preskaler-256 / licznik zlicza 250 / jeszcze nasze "zliczanie"-125 = 1 Hz :) */

static uint8_t zliczanie = 0;
if (zliczanie)/*ta zmienne jest dekrementowana 125 razy na sekunde, */
{
zliczanie--;
}
else
{ /*wiec co sekunde osiaga 0 i trzeba znowu wpisac do niej 125*/
zliczanie = 125;
static uint8_t kolejnosc_anod;

kolejnosc_anod++;
if (kolejnosc_anod > 3) kolejnosc_anod = 0;

WYGAS_ANODY;
if (kolejnosc_anod == 0)
A_1_ON;
else
if (kolejnosc_anod == 1)
A_2_ON;
else
if (kolejnosc_anod == 2)
A_3_ON;
else
if (kolejnosc_anod == 3)
A_4_ON;

}

}[/syntax]Dziś zdążyłem tylko tyle.
jutro mam znowu kocioł w pracy i po też.

Statystyki: Napisane przez Daro69 — 8 wrz 2016, o 23:28