ATNEL tech-forum 2015-01-08T23:10:43+01:00 https://forum.atnel.pl/feed.php?f=4&t=9921&mode 2015-01-08T23:10:43+01:00 2015-01-08T23:10:43+01:00 https://forum.atnel.pl/viewtopic.php?t=9921&p=113269#p113269 <![CDATA[Re: Tablica, RS232, Wyświetlacz led]]> Uroki początków, robi się dużo na około.

Mam jednak pytanko:

1.Czemu w podfunkcji dałeś w nawias VOID a nie mógł zostać pusty?
2.Dlaczego jest *licznik_2 w nawiasie po uint8_t? a potem w timerze2 gdzie jest definiowana ta zmienna jest odnośnik do podfunkcji &licznik_2?
[syntax=c]void off_segment(uint8_t *licznik_2)
{
(*licznik_2)++;
if(*licznik_2==1)
{
PORTC|=cyf1|cyf2|cyf3;
PORTC&=~cyf4;
PORTD=waga[5];
}
// zwiekszenie licznika
if(*licznik_2==200) // po zliczeniu do tego ma sie wylaczyc wyswietlacz
{
PORTC|=cyf1|cyf2|cyf3|cyf4;
*licznik_2=2;
}
}
ISR (TIMER2_COMP_vect) //przerwanie nadajnika podczerwieni
{
static uint8_t licznik_2;
if(j==1)
{
multiplex(& licznik_2);
}
if(j==2) off_segment(& licznik_2);
}[/syntax]

Może i to pytania o błahostkę ale jedyne czego tu nie czaje za bardzo ;)

Statystyki: Napisane przez fotograf9 — 8 sty 2015, o 23:10

]]> 2015-01-08T21:07:47+01:00 2015-01-08T21:07:47+01:00 https://forum.atnel.pl/viewtopic.php?t=9921&p=113222#p113222 <![CDATA[Re: Tablica, RS232, Wyświetlacz 7-seg]]> Program ma na celu wyświetlanie odebranej ramki danych na wyświetlaczu 7segmentowym. W życiu będzie wykorzystanych 6 segementów jednak do testów na płytce stykowej mam jedynie 4 dlatego jest nieco obkrojony kod ;)

W przerwaniu odczytywana jest cała ramka i zapisywana do tablicy, poczym sprawdzane jest czy charakterystyczne znaki na danych miejscach zostały odebrane co świadczy o poprawnej ramce, dalej funkcja wycisna z ramki odpowiednie znaki i wpisuje je do tablicy waga. Gdy jest zero po krótkim czasie przechodzi w stan czuwania i się wygasza, taka sama sytuacja jest gdy nie ma transmisji


[syntax=c]/*
* main.c
*
* Created on: 08-01-2015
* Author: Błażej
*/



#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "UART/UART.h"

#define cyf1 (1<<PC0)
#define cyf2 (1<<PC1)
#define cyf3 (1<<PC2)
#define cyf4 (1<<PC3)

void Timer1_init ();
void Timer2_init ();
void sprawdzenie_cyfr();
void multiplex ();
void off_segment();


uint8_t licznik=1, licznik_2=0;
uint8_t odebrano,j;
uint8_t z=1,y=0;
int i;
uint8_t ramka[22], waga[]={255,255,255,255,255,255};
const uint8_t cyfra[12] = { //tablica zapalanych segmentów
0b10000001,// 0
0b11110011,// 1
0b01001001,// 2
0b01100001,// 3
0b00110011,// 4
0b00100101,// 5
0b00000101,// 6
0b11110001,// 7
0b00000001,// 8
0b00100001,// 9
0b11111111,// NIC (puste miejsce)
0b01111111, // minus
};

int main(void)
{
DDRD=0b11111110;
PORTD=0xff;
DDRC=0b00111111;
PORTC=0xff;

UART_init(9600);
Timer2_init ();
Timer1_init ();
sei ();

while(1)
{
if(ramka[0]==0x02 && ramka[19]==0x0d && ramka[21]==0x04) //warunek poprawnej ramki STX,CR,ETX
{
sprawdzenie_cyfr(); //odwołanie do funkcji sprawdzania cyfr
}
if (waga[4]==cyfra[10] && waga[5]==cyfra[0]) j=2;
else j=1;
if(y==z)
{
j=0;
PORTC|=cyf1|cyf2|cyf3|cyf4;
}
}
}

void Timer2_init ()
{
TCCR2 |= (1<<WGM21); //tryb CTC
TCCR2 |= (1<<CS21)|(1<<CS22)|(1<<CS20); //preskaler na 1024
OCR2 = 38; //rejestr przepelnienia, czestotliwosc 200Hz
TIMSK |= (1<<OCIE2); //zezwolenie na przerwanie
}

void Timer1_init ()
{
TCCR1B|=(1<<WGM12); //tryb ctc
TCCR1B|=(1<<CS12)|(1<<CS10); //preskaler 1024
OCR1A =31249; //rejestr przepełeninia, czestotliwosc 0.25Hz
TIMSK|=(1<<OCIE1A);//zezwolenie na przerwanie
}
/**************************************************************************************************
*************************************PODFUNKCJE****************************************************
**************************************************************************************************/
void sprawdzenie_cyfr()
{
for(uint8_t k=1;k<7;k++) //petla liczaca kolejne miejsca w ramce
{
for(uint8_t j=0;j<10;j++) //petla odliczajaca przypisanie cyfr
{
if(ramka[k]==0x20) waga[k-1]=cyfra[10]; //jeżeli w ramce jest znak pusty
else if(ramka[k]==0x2D) waga[k-1]=cyfra[11]; //jeżeli w ramce jest minus
else if(ramka[k]==0x30+j) waga[k-1]=cyfra[j]; //cyfry z wagi
}
}
}

void multiplex()
{
// zmienna do przelaczania kolejno anod wyswietlacza

if(licznik==1) PORTD=waga[2];// gdy zapalony wysw.1 podaj stan zmiennej c1
else if(licznik==2) PORTD=waga[3];// gdy zapalony wysw.2 podaj stan zmiennej c2
else if(licznik==4) PORTD=waga[4];// gdy zapalony wysw.3 podaj stan zmiennej c3
else if(licznik==8) PORTD=waga[5];// gdy zapalony wysw.4 podaj stan zmiennej c4
PORTC = (PORTC & 0xF0) | (~licznik & 0x0F);
// operacje cyklicznego przesuwania bitu zapalajacego anody w zmiennej licznik
licznik <<= 1;// przesuniecie zawartosci bitow licznika o 1 w lewo
if(licznik>8)
{
licznik = 1;// jesli licznik wi?kszy niz 8 to ustaw na 1
}
j=0;
licznik_2=0;
}

void off_segment()
{
licznik_2++;
if(licznik_2==1)
{
PORTC|=cyf1|cyf2|cyf3;
PORTC&=~cyf4;
PORTD=waga[5];
}
// zwiekszenei licznika
if(licznik_2==200) // po zliczeniu do tego ma sie wylaczyc wyswietlacz
{
PORTC|=cyf1|cyf2|cyf3|cyf4;
licznik_2=2;
}
}
/**************************************************************************************************
********************************************PRZERWANIA*********************************************
**************************************************************************************************/
ISR (USART_RXC_vect) //przerwanie odczytu danych
{
odebrano=odbierz();
ramka[i]=odebrano; //to co odebrano przypisz do ramki
i++;
if(i==22) i=0; //jezeli odebrano 22 znaki wyzeruj licznik i, odebrano cała ramke
z++;
if(z==250) z=1;
}
ISR (TIMER2_COMP_vect) //przerwanie nadajnika podczerwieni
{
if(j==1)
{
multiplex();
}
if(j==2) off_segment();
}
ISR (TIMER1_COMPA_vect)
{
y=z;
}[/syntax]

Jeżeli macie jakieś sugestie co do uproszczenia kodu prosze o info ;) Jedyne co jest denerwujące to to, że podczas trwania przerwania Timera1, ktore odywa się co ok. 4sekundy wyświetlacz zamruga. Można to jakoś wyeliminować czy to już taki urok multipleksowania?

Statystyki: Napisane przez fotograf9 — 8 sty 2015, o 21:07

]]> 2014-12-29T21:33:02+01:00 2014-12-29T21:33:02+01:00 https://forum.atnel.pl/viewtopic.php?t=9921&p=111163#p111163 <![CDATA[Re: Tablica, RS232, Wyświetlacz led]]>
[syntax=c]sprawdzenie_cyfr1();
sprawdzenie_cyfr2();
sprawdzenie_cyfr3();
sprawdzenie_cyfr4();[/syntax]
Zastępując je:

[syntax=c]for (uint8_t i = 0; i < 4; i++)
for (uint8_t j = 0; j < 10; ++j)
if(ramka[i + 3]==0x20)
waga[i] = cyfra[10];
else if(ramka[i + 3]==0x2D)
waga[i] = cyfra[11];
else if(ramka[i + 3] == 0x30 + j)
waga[i]=cyfra[j];[/syntax]

Co do samego problemu to proponuję dodać "timeout" na jakimś timerze, którego zliczona wartość będzie resetowana w momencie odbioru dowolnej danej. Jeżeli licznik doliczy do ustalonego Tmax, wtedy wyświetlanie jest wyłączane, a moment odbioru bajtu z powrotem włącza wyświetlacz.

Statystyki: Napisane przez atmel — 29 gru 2014, o 21:33

]]> 2014-12-29T20:19:24+01:00 2014-12-29T20:19:24+01:00 https://forum.atnel.pl/viewtopic.php?t=9921&p=111139#p111139 <![CDATA[Tablica, RS232, Wyświetlacz led]]>

Mam taki mały problemik. Program ma za zadania odczytu ramki danych przesyłanej przez interfejs RS232 i wyświetlanie przesłanych cyfr na wyświetlaczu siedmiosegmentowym. Po braku transmisji (wyłączenie nadajnika) wyświetlacze led mają się wyłączać jednak nie mam pomysłu jak to uczynić. Domyślam się, że potrzeba warunku sprawdzającego czy leci transmisja i potem przypisanie do tablicy odpowiednich znaków odpowiadających za wygaszenie LED.

Poniżej kod programu:
[syntax=c]/*
* main.c
*
* Created on: 11-12-2014
* Author: Błażej
*/


#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "UART/UART.h"

#define cyf1 (1<<PB0)
#define cyf2 (1<<PB1)
#define cyf3 (1<<PB2)
#define cyf4 (1<<PB3)

void sprawdzenie_cyfr1();
void sprawdzenie_cyfr2();
void sprawdzenie_cyfr3();
void sprawdzenie_cyfr4();

uint8_t odebrano;
int i;
char ramka[22], waga[6];

const uint8_t cyfra[12] = {
0b10000001,// 0
0b11110011,// 1
0b01001001,// 2
0b01100001,// 3
0b00110011,// 4
0b00100101,// 5
0b00000101,// 6
0b11110001,// 7
0b00000001,// 8
0b00100001,// 9
0b11111111,// NIC (puste miejsce)
0b01111111,// minus
};

int main(void)
{
DDRD=0b11111110;
PORTD=0x00;
DDRB=0b00001111;
PORTB|=cyf1 |cyf2 |cyf3 | cyf4;

UART_init(9600);
sei ();


while(1)
{
if(ramka[0]==0x02 && ramka[19]==0x0d && ramka[21]==0x04)
{
sprawdzenie_cyfr1();
sprawdzenie_cyfr2();
sprawdzenie_cyfr3();
sprawdzenie_cyfr4();
}

if(ramka[0]==0x02)
{
PORTB &=~cyf1;
PORTB|=cyf2|cyf3|cyf4;
PORTD=waga[0];
_delay_ms(1);

PORTB &=~cyf2;
PORTB|=cyf1|cyf3|cyf4;
PORTD=waga[1];
_delay_ms(1);

PORTB &=~cyf3;
PORTB|=cyf2|cyf1|cyf4;
PORTD=waga[2];
_delay_ms(1);

PORTB &=~cyf4;
PORTB|=cyf2|cyf3|cyf1;
PORTD=waga[3];
_delay_ms(1);
}
}
}

void sprawdzenie_cyfr1()
{
if(ramka[3]==0x30) waga[0]=cyfra[0];
if(ramka[3]==0x31) waga[0]=cyfra[1];
if(ramka[3]==0x32) waga[0]=cyfra[2];
if(ramka[3]==0x33) waga[0]=cyfra[3];
if(ramka[3]==0x34) waga[0]=cyfra[4];
if(ramka[3]==0x35) waga[0]=cyfra[5];
if(ramka[3]==0x36) waga[0]=cyfra[6];
if(ramka[3]==0x37) waga[0]=cyfra[7];
if(ramka[3]==0x38) waga[0]=cyfra[8];
if(ramka[3]==0x39) waga[0]=cyfra[9];
if(ramka[3]==0x20) waga[0]=cyfra[10];
if(ramka[3]==0x2D) waga[0]=cyfra[11];
}

void sprawdzenie_cyfr2()
{
if(ramka[4]==0x30) waga[1]=cyfra[0];
if(ramka[4]==0x31) waga[1]=cyfra[1];
if(ramka[4]==0x32) waga[1]=cyfra[2];
if(ramka[4]==0x33) waga[1]=cyfra[3];
if(ramka[4]==0x34) waga[1]=cyfra[4];
if(ramka[4]==0x35) waga[1]=cyfra[5];
if(ramka[4]==0x36) waga[1]=cyfra[6];
if(ramka[4]==0x37) waga[1]=cyfra[7];
if(ramka[4]==0x38) waga[1]=cyfra[8];
if(ramka[4]==0x39) waga[1]=cyfra[9];
if(ramka[4]==0x20) waga[1]=cyfra[10];
if(ramka[4]==0x2D) waga[1]=cyfra[11];
}

void sprawdzenie_cyfr3()
{
if(ramka[5]==0x30) waga[2]=cyfra[0];
if(ramka[5]==0x31) waga[2]=cyfra[1];
if(ramka[5]==0x32) waga[2]=cyfra[2];
if(ramka[5]==0x33) waga[2]=cyfra[3];
if(ramka[5]==0x34) waga[2]=cyfra[4];
if(ramka[5]==0x35) waga[2]=cyfra[5];
if(ramka[5]==0x36) waga[2]=cyfra[6];
if(ramka[5]==0x37) waga[2]=cyfra[7];
if(ramka[5]==0x38) waga[2]=cyfra[8];
if(ramka[5]==0x39) waga[2]=cyfra[9];
if(ramka[5]==0x20) waga[2]=cyfra[10];
if(ramka[5]==0x2D) waga[2]=cyfra[11];
}

void sprawdzenie_cyfr4()
{
if(ramka[6]==0x30) waga[3]=cyfra[0];
if(ramka[6]==0x31) waga[3]=cyfra[1];
if(ramka[6]==0x32) waga[3]=cyfra[2];
if(ramka[6]==0x33) waga[3]=cyfra[3];
if(ramka[6]==0x34) waga[3]=cyfra[4];
if(ramka[6]==0x35) waga[3]=cyfra[5];
if(ramka[6]==0x36) waga[3]=cyfra[6];
if(ramka[6]==0x37) waga[3]=cyfra[7];
if(ramka[6]==0x38) waga[3]=cyfra[8];
if(ramka[6]==0x39) waga[3]=cyfra[9];
if(ramka[6]==0x20) waga[3]=cyfra[10];
if(ramka[6]==0x2D) waga[3]=cyfra[11];
}

ISR (USART_RXC_vect) //przerwanie odczytu danych
{
odebrano=odbierz();
ramka[i]=odebrano;
i++;
if(i==22)i=0;
}[/syntax]

I tu w razie co inicjalizacja UART:
[syntax=c]/*
* UART.c
*
* Created on: 21-08-2014
* Author: B?a?ej
*/

#include "avr/io.h"
#include "UART.h"
#include "avr/pgmspace.h"
#include "stdlib.h" //biblioteka do ltoa

void UART_init( uint16_t baud)
{
uint16_t _UBRR = ((8000000+baud*8UL)/(16UL*baud)-1);
UBRRH = (uint8_t)(_UBRR>>8);
UBRRL = (uint8_t) _UBRR;
UCSRB = (1<<RXCIE) | (1<<RXEN);//| (1<<TXEN); //ustawienie odbierania, wysy��ania i flagi odebrania danych

}

uint8_t odbierz(void) //odbieranie pojedynczego znaku
{
while (!( UCSRA & (1<<RXC))) ; //czeka az bufor bedzie pusty
return UDR; //przeslanie do bufora znaku
}
void UART_putc(char data ) //wysy��anie pojdeynczego znaku
{
while ( !( UCSRA & (1<<UDRE)) ); //czeka a��� bufor b���dzie pusty
UDR = data; //przes���anie do bufora znaku
}

void UART_puts(char *s) //wysy��anie ciagu znak��w
{
while (*s) UART_putc(*s++);
}

void UART_putlong (uint32_t liczba, uint8_t radix) //radix czyli jaki system zapisu liczb wybieramy
{
char buf[17];
ltoa(liczba, buf, radix); //zamiana liczby na znak ascii
UART_puts(buf);
}[/syntax]

Kombinowałem z flagą odbioru danych ale kompletnie mi to nie wychodzi, jakby były jakieś trafne sugestie, z góry dzięki ;)

Statystyki: Napisane przez fotograf9 — 29 gru 2014, o 20:19

]]>