ATNEL tech-forum 2016-01-11T18:40:11+01:00 https://forum.atnel.pl/feed.php?f=58&t=7390&mode 2016-01-11T18:40:11+01:00 2016-01-11T18:40:11+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=150273#p150273 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]> Podłączenie wygląda tak:
Obrazek
PCD8544 podłączone:
RST - RES
CE - SCE
DC - D/C
DIN - SDIN
CLK - SCLK
VCC - VDD
BL - VOUT
GND - GND

Program wygląda następująco:
lcd.c:
[syntax=c]/*
Plik lcd.c

LCD od nokia 3310 przykład 4
KURS AVR-GCC (www.abxyz.bplaced.net)

testowane na atmega88 (8MHz)
*/
#include <stdio.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "lcd.h"



// Inicjuje wyświetlacz
void lcd_init(void)
{
LCD_RST_CLR;

LCD_RST_SET_OUT
LCD_CLK_SET_OUT
LCD_DATA_SET_OUT
LCD_DC_SET_OUT
LCD_CE_SET_OUT


// < 30ms
_delay_ms(15);

LCD_RST_SET

LCD_CE_SET

lcd_write_byte(LCD_CMD, 0x21); // Function set - extended instruction set
lcd_write_byte(LCD_CMD, 0x13); // Bias - 1:48
lcd_write_byte(LCD_CMD, 0x06); // Temperature Control
lcd_write_byte(LCD_CMD, 0xA5); // Set Vop
lcd_write_byte(LCD_CMD, 0x20); // Function set - basic instruction set, horizontal addressing
lcd_write_byte(LCD_CMD, 0x0C); // Display control - normal mode
}


// Wysyła do LCD jeden bajt
// c_d: LCD_DATA|LCD_CMD
void lcd_write_byte(unsigned char c_d, unsigned char data )
{
unsigned char m;

LCD_CE_CLR

if(c_d) LCD_DC_SET else LCD_DC_CLR

for(m=0x80; m; m>>=1)
{
if(data & m)
LCD_DATA_SET
else
LCD_DATA_CLR

LCD_CLK_SET
LCD_NOP
LCD_CLK_CLR
}

LCD_CE_SET
}


// Wyświetla obrazek
// img - dane obrazka
// x - pierwsza kolumna 0..84(96)
// y - pierwszy wiersz 0..5(7)
// w - szerokość obrazka 0..84(96)
// h - wysokość obrazka 0..5(7)
void lcd_image(unsigned char img[],char x, char y, char w, char h)
{
unsigned int i,j,k;

for(i=0,j=0,k=0; i<h; i++)
{
// Ustawia położenia lewego górnego robu obrazka na ekranie LCD
lcd_write_byte(LCD_CMD, LCD_SETY|(i+y));
lcd_write_byte(LCD_CMD, LCD_SETX|(x));

// Kopiuje dane obrazka z FLASH do pamięci obrazu LCD
for(j=0; j<w ; j++,k++)
lcd_write_byte(LCD_DATA, pgm_read_byte(&img[k]));
}
}[/syntax]
lcd.h:
[syntax=c]/*
Plik "lcd.h"

LCD od nokia3310 przykład 4
KURS AVR-GCC www.abxyz.bplaced.net

testowane na atmega88 (8MHz)
*/

#ifndef PCD8544_H
#define PCD8544_H


// Użycie sprzętowego interfejsu SPI
#define ATMEGA_SPI 1

//
#define LCD_X 84
#define LCD_Y 6


// CLK
#define LCD_CLK_SET PORTB |= (1<<PB5);
#define LCD_CLK_CLR PORTB &= ~(1<<PB5);
#define LCD_CLK_SET_OUT DDRB |= (1<<PB5);
// DATA
#define LCD_DATA_SET PORTB |= (1<<PB3);
#define LCD_DATA_CLR PORTB &= ~(1<<PB3);
#define LCD_DATA_SET_OUT DDRB |= (1<<PB3);
// DC
#define LCD_DC_SET PORTB |= (1<<PB1);
#define LCD_DC_CLR PORTB &= ~(1<<PB1);
#define LCD_DC_SET_OUT DDRB |= (1<<PB1);
// CE
#define LCD_CE_SET PORTB |= (1<<PD7);
#define LCD_CE_CLR PORTB &= ~(1<<PD7);
#define LCD_CE_SET_OUT DDRB |= (1<<PD7);
// RST
#define LCD_RST_SET PORTB |= (1<<PB0);
#define LCD_RST_CLR PORTB &= ~(1<<PB0);
#define LCD_RST_SET_OUT DDRB |= (1<<PB0);


#define LCD_NOP asm volatile("nop\n\t""nop\n\t" "nop\n\t" "nop\n\t" "nop\n\t" "nop\n\t" "nop\n\t" "nop\n\t" ::);

#define LCD_CMD 0
#define LCD_DATA 1

// INSTRUCTION - FUNCTION SET
#define LCD_FUNCTIONSET 0x20
#define LCD_FUNC_PD(x) LCD_FUNCTIONSET | ((x) << 2) // Function set - chip is active(0)/powered-down(1)
#define LCD_FUNC_V(x) LCD_FUNCTIONSET | ((x) << 1) // Function set - horizontal(0)/vertical(1) addressing
#define LCD_FUNC_H(x) LCD_FUNCTIONSET | (x) // Function set - basic(0)/extended(1) instruction set

#define LCD_SETX 0x80
#define LCD_SETY 0x40

#define LCD_GOTO_HOME lcd_write_byte(LCD_CMD, LCD_SETY);lcd_write_byte(LCD_CMD, LCD_SETX);
#define LCD_GOTO(x,y) lcd_write_byte(LCD_CMD, LCD_SETY|(y));lcd_write_byte(LCD_CMD, LCD_SETX|(x));

void lcd_init(void);
void lcd_clear(void);
void lcd_write_byte( unsigned char, unsigned char );
void lcd_text(char [], unsigned char , unsigned char );
void lcd_image(unsigned char [],char , char , char , char );


#endif[/syntax]
main.c:
[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <util/crc16.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include "ds18b20.h"
#include "lcd.h"

// Obrazek z cyferkami dla wska¼nika cyfrowego
const unsigned char digits8x16[] PROGMEM = {
#include "dig8x16.h"
};

// Obrazek z t³em
const unsigned char screen[] PROGMEM = {
#include "screen.h"
};

volatile unsigned char odb_x; //odebrana liczba X
volatile unsigned char odb_flaga =0;//flaga informujaca main o odebraniu liczby
volatile unsigned char wys_flaga =0;
#define IS_RELAY_ON PIND & (1 << PD2)
//bufor znaków ze wzorem funkcji, który wysylamy po starcie programu
volatile unsigned int usart_bufor_ind; //indeks bufora nadawania
char usart_bufor[30] = "Odbiornik test START";

//
unsigned char tab[8];

// 9 bajtów odczytanych z ds18b20
unsigned char ds18b20_pad[9];

void usart_inicjuj(void)
{
//definiowanie parametrów transmisji za pomoca makr zawartych w pliku
//naglówkowym setbaud.h. Jezeli wybierzesz predkosc, która nie bedzie
//mozliwa do realizacji otrzymasz ostrzezenie:
//#warning "Baud rate achieved is higher than allowed"

#define BAUD 9600
#include <util/setbaud.h>
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
#if USE_2X
UCSR0A |= (1 << U2X0);
#else
UCSR0A &= ~(1 << U2X0);
#endif
// Enable receiver and transmitter
UCSR0B = (1<<RXEN0)| (1<<TXEN0) | (1<<RXCIE0);
// Set frame format: 8data, 2stop bit
UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
}


//--------------------------------------------------------------


ISR(USART_RX_vect)
{
//przerwanie generowane po odebraniu bajtu
odb_x = UDR0; //zapamietaj odebrana liczbe
odb_flaga = 1; //ustaw flage odbioru liczby dla main()
}


//--------------------------------------------------------------

ISR(USART_UDRE_vect){

//przerwanie generowane, gdy bufor nadawania jest juz pusty,
//odpowiedzialne za wyslanie wszystkich znaków z tablicy usart_bufor[]

//sprawdzamy, czy bajt do wyslania jest znakiem konca tekstu, czyli zerem
if(usart_bufor[usart_bufor_ind]!= 0){

//zaladuj znak do rejestru wysylki i ustaw indeks na nastepny znak
UDR0 = usart_bufor[usart_bufor_ind++];

}else{

//osiagnieto koniec napisu w tablicy usart_bufor[]
UCSR0B &= ~(1<<UDRIE0); //wylacz przerwania pustego bufora nadawania
wys_flaga = 1;
}
}


//--------------------------------------------------------------


void wyslij_wynik(void){

//funkcja rozpoczyna wysylanie, wysylajac pierwszy znak znajdujacy sie
//w tablicy usart_bufor[]. Pozostale wysle funkcja przerwania,
//która zostanie wywolana automatycznie po wyslaniu kazdego znaku.

//dodaj do tekstu wyniku znaki konca linii (CR+LF), by na
//ekranie terminala wyniki pojawialy sie w nowych liniach
unsigned char z;
wys_flaga = 0;
for(z=0; z<30; z++)
{
if(usart_bufor[z]==0)
{ //czy to koniec takstu w tablicy
usart_bufor[z] = 13; //znak powrotu karetki CR (Carrige Return)
usart_bufor[z+1] = 10; //znak nowej linii LF (Line Feed)
usart_bufor[z+2] = 0; //znak konca ciagu tekstu w tablicy
break;
}
}


//Zaczekaj, az bufor nadawania bedzie pusty
while (!(UCSR0A & (1<<UDRE0)));

//bufor jest pusty mozna wyslac

//nastepny znak do wysylki to znak nr 1
usart_bufor_ind = 0;

//wlacz przerwania pustego bufora UDR, co rozpocznie transmisje
//aktualnej zawartosci bufora
UCSR0B |= (1<<UDRIE0);

}


// MAIN
int main(void)
{
unsigned int crc = 0;
unsigned char i;

int t; // wartość temperatury * 16
usart_inicjuj(); //inicjuj modul USART (RS-232)
lcd_init();

sei();
wyslij_wynik();
while (!wys_flaga);


lcd_image(screen,0,0,84,6);

while(1)
{
if(odb_flaga)
if(ds18b20_ConvertT())
{
sprintf(usart_bufor, "Temp Conversion.");
wyslij_wynik();
while (!wys_flaga);
// Zatrzymuje do czasu zakończenia pomiaru
while(!OneWireReadTimeSlot());

sprintf(usart_bufor, "Read Temp.");
wyslij_wynik();
while (!wys_flaga);
// Odczyt danych z ds18b20
ds18b20_Read(ds18b20_pad);
sprintf(usart_bufor, "Check CRC.");
wyslij_wynik();
while (!wys_flaga);
// Oblicza sumę kontrolną CRC danych odczytanych z ds18b20
for (i = 0, crc =0; i < 9; i++)
crc = _crc_ibutton_update(crc, ds18b20_pad[i]);

// Jeśli suma kontrolna się zgadza,
// pokazuje nowe wyniki pomiaru
if(!crc)
{
sprintf(usart_bufor, "CRC OK!");
wyslij_wynik();
while (!wys_flaga);
// Zmienna "t" zawiera wartość temperatury * 16
t = ((ds18b20_pad[0] >> 1) - 0.25) + (ds18b20_pad[7] - ds18b20_pad[6])/ds18b20_pad[7];
sprintf(usart_bufor, "TEMP: %d", t);
wyslij_wynik();
while (!wys_flaga);
} else
{
sprintf(usart_bufor, "CRC BAD.");
wyslij_wynik();
while (!wys_flaga);
}
odb_flaga = 0;
}
}

return 0;
}[/syntax]

Niestety po odpaleniu Atmegi na ekranie nic się nie dzieje - a powinien widnieć elegancki ekranik.
Kod ekraniku:
[syntax=c]0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x02,0x02,0xfe,0xfe,0x02,0x02,0x02,0x00,0xf8,0xf8,0x88,0x88,0x08,
0x00,0x00,0xf8,0xf8,0x30,0x60,0xc0,0x60,0x30,0xf8,0xf8,0x00,0x00,0xf8,0xf8,0x08,
0x08,0xf8,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0x42,0x02,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x00,0x00,0x00,0x00,0x0f,
0x0f,0x08,0x08,0x08,0x00,0x00,0x0f,0x0f,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x00,
0x00,0x0f,0x0f,0x01,0x01,0x01,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,0x08,0x08,0x00,0x22,
0x21,0x29,0x36,0x00,0x1e,0x21,0x21,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0xff,
0x21,0x20,0x00,0x88,0xc4,0xa4,0x98,0x00,0x78,0x84,0x84,0x78,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
0x00,0x00,0x00,0xff,0x84,0x80,0x00,0x40,0x20,0xf0,0x00,0xe0,0x10,0x10,0xe0,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x10,0x10,0x68,0x86,0x00,0x00,
0x78,0x80,0x80,0x80,0x78,0x00,0x00,0xf0,0x08,0x08,0x08,0x00,0x90,0xa8,0xa8,0x68,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xff,0x80,0x80,0x80,0xff,0x10,0x00,0x00,0x00,0x00,0x03,0x00,0x81,
0x42,0x42,0x81,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0xfc,0x22,0x22,0x22,0xfc,0x00,0x3e,0x40,0x80,0x40,0x3e,0x00,
0xfe,0x12,0x32,0x52,0x8c,0x00,0x10,0x10,0x10,0x10,0x10,0x00,0x7c,0x82,0x82,0x92,
0xf4,0x00,0x7c,0x82,0x82,0x82,0x44,0x00,0x7c,0x82,0x82,0x82,0x44,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0x42,0x02,0x02,0x00,
0x00,0x00,0x00,0x07,0x08,0x08,0x07,0x00[/syntax]

Jakieś propozycje co można sprawdzić?

Statystyki: Napisane przez mkk13 — 11 sty 2016, o 18:40

]]> 2016-01-10T22:27:19+01:00 2016-01-10T22:27:19+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=150215#p150215 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]>
Zamiast zakładać własny temat, uznałem że kontynuuję ten, bo bardzo dobrze oddaje i moją sytuację.
Atmega88PA-PU, USART działa i korzystam w celu debug'u. Wykorzystany termometr to DS18S20Z+ od Maxima.
Atmega działa póki co na 1MHz.

Kod wygląda następująco:
ds18b20.h
[syntax=c]#ifndef DS18B20_H
#define DS18B20_H

// DS18B20 przyłączony do portu PD7 AVRa
#define SET_ONEWIRE_PORT PORTC |= _BV(PC5)
#define CLR_ONEWIRE_PORT PORTC &= ~_BV(PC5)
#define IS_SET_ONEWIRE_PIN PINC & _BV(PC5)
#define SET_OUT_ONEWIRE_DDR DDRC |= _BV(PC5)
#define SET_IN_ONEWIRE_DDR DDRC &= ~_BV(PC5)
#define CMD_CONVERT_T 0x44
#define CMD_SKIP_ROM 0xCC
#define CMD_READ_SCRATCH 0xBE


char ds18b20_ConvertT(void);
char ds18b20_Read(unsigned char []);
void OneWireStrong(char);
unsigned char OneWireReset(void);
void OneWireWriteByte(unsigned char);
unsigned char OneWireReadByte(void);
unsigned char OneWireReadTimeSlot(void);


#endif[/syntax]

ds18b20.c
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include "ds18b20.h"




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

char ds18b20_ConvertT(void)
{
if (!OneWireReset()) return 0;

OneWireWriteByte(CMD_SKIP_ROM);
OneWireWriteByte(CMD_CONVERT_T);

return 0xff;
}

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

char ds18b20_Read(unsigned char scratchpad[])
{
unsigned char i;

if (!OneWireReset()) return 0;

OneWireWriteByte(CMD_SKIP_ROM);
OneWireWriteByte(CMD_READ_SCRATCH);

for(i=0; i<10; i++) scratchpad[i] = OneWireReadByte();

return 0xff;
}

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

void OneWireStrong(char s)
{
if (s)
{
SET_ONEWIRE_PORT;
SET_OUT_ONEWIRE_DDR;
}
else
{
SET_IN_ONEWIRE_DDR;
}
}

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

unsigned char OneWireReset()
{
SET_IN_ONEWIRE_DDR;
CLR_ONEWIRE_PORT;

if (!(IS_SET_ONEWIRE_PIN)) return 0;

SET_OUT_ONEWIRE_DDR;
_delay_us(500);
SET_IN_ONEWIRE_DDR;
_delay_us(70);

if(!(IS_SET_ONEWIRE_PIN))
{
_delay_us(500);
return(1);
}

_delay_us(500);

return(0);
}

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

void OneWireWriteByte(unsigned char byte)
{
unsigned char i;

SET_IN_ONEWIRE_DDR;
CLR_ONEWIRE_PORT;

for (i=0; i<8; i++)
{
SET_OUT_ONEWIRE_DDR;

if (byte & 0x01)
{
_delay_us(7);
SET_IN_ONEWIRE_DDR;
_delay_us(70);
}
else
{
_delay_us(70);
SET_IN_ONEWIRE_DDR;
_delay_us(7);
}

byte >>= 1;
}
}

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

unsigned char OneWireReadByte(void)
{
unsigned char i, byte = 0;

CLR_ONEWIRE_PORT;
SET_IN_ONEWIRE_DDR;

for (i=0; i<8; i++)
{
SET_OUT_ONEWIRE_DDR;
_delay_us(7);
SET_IN_ONEWIRE_DDR;
_delay_us(7);
byte >>= 1;

if(IS_SET_ONEWIRE_PIN) byte |= 0x80;

_delay_us(70);
}

return byte;
}

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

unsigned char OneWireReadTimeSlot(void)
{
unsigned char byte = 0;

CLR_ONEWIRE_PORT;
SET_IN_ONEWIRE_DDR;

SET_OUT_ONEWIRE_DDR;
_delay_us(7);
SET_IN_ONEWIRE_DDR;
_delay_us(7);

if(IS_SET_ONEWIRE_PIN) byte = 0xff;
_delay_us(70);

return byte;
}[/syntax]

main.c
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <util/crc16.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include "ds18b20.h"


volatile unsigned char odb_x; //odebrana liczba X
volatile unsigned char odb_flaga =0;//flaga informujaca main o odebraniu liczby
volatile unsigned char wys_flaga =0;
#define IS_RELAY_ON PIND & (1 << PD2)
//bufor znaków ze wzorem funkcji, który wysylamy po starcie programu
volatile unsigned int usart_bufor_ind; //indeks bufora nadawania
char usart_bufor[30] = "Odbiornik test START";

//
unsigned char tab[8];

// 9 bajtów odczytanych z ds18b20
unsigned char ds18b20_pad[9];

void usart_inicjuj(void)
{
//definiowanie parametrów transmisji za pomoca makr zawartych w pliku
//naglówkowym setbaud.h. Jezeli wybierzesz predkosc, która nie bedzie
//mozliwa do realizacji otrzymasz ostrzezenie:
//#warning "Baud rate achieved is higher than allowed"

#define BAUD 9600
#include <util/setbaud.h>
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
#if USE_2X
UCSR0A |= (1 << U2X0);
#else
UCSR0A &= ~(1 << U2X0);
#endif
// Enable receiver and transmitter
UCSR0B = (1<<RXEN0)| (1<<TXEN0) | (1<<RXCIE0);
// Set frame format: 8data, 2stop bit
UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
}


//--------------------------------------------------------------


ISR(USART_RX_vect)
{
//przerwanie generowane po odebraniu bajtu
odb_x = UDR0; //zapamietaj odebrana liczbe
odb_flaga = 1; //ustaw flage odbioru liczby dla main()
}


//--------------------------------------------------------------

ISR(USART_UDRE_vect){

//przerwanie generowane, gdy bufor nadawania jest juz pusty,
//odpowiedzialne za wyslanie wszystkich znaków z tablicy usart_bufor[]

//sprawdzamy, czy bajt do wyslania jest znakiem konca tekstu, czyli zerem
if(usart_bufor[usart_bufor_ind]!= 0){

//zaladuj znak do rejestru wysylki i ustaw indeks na nastepny znak
UDR0 = usart_bufor[usart_bufor_ind++];

}else{

//osiagnieto koniec napisu w tablicy usart_bufor[]
UCSR0B &= ~(1<<UDRIE0); //wylacz przerwania pustego bufora nadawania
wys_flaga = 1;
}
}


//--------------------------------------------------------------


void wyslij_wynik(void){
//dodaj do tekstu wyniku znaki konca linii (CR+LF), by na
//ekranie terminala wyniki pojawialy sie w nowych liniach
unsigned char z;
wys_flaga = 0;
for(z=0; z<30; z++)
{
if(usart_bufor[z]==0)
{ //czy to koniec takstu w tablicy
usart_bufor[z] = 13; //znak powrotu karetki CR (Carrige Return)
usart_bufor[z+1] = 10; //znak nowej linii LF (Line Feed)
usart_bufor[z+2] = 0; //znak konca ciagu tekstu w tablicy
break;
}
}


//Zaczekaj, az bufor nadawania bedzie pusty
while (!(UCSR0A & (1<<UDRE0)));

//bufor jest pusty mozna wyslac

//nastepny znak do wysylki to znak nr 1
usart_bufor_ind = 0;

//wlacz przerwania pustego bufora UDR, co rozpocznie transmisje
//aktualnej zawartosci bufora
UCSR0B |= (1<<UDRIE0);

}


// MAIN
int main(void)
{
unsigned int crc = 0;
unsigned char i;

int t; // wartość temperatury * 16
usart_inicjuj(); //inicjuj modul USART (RS-232)
sei();
wyslij_wynik();
while (!wys_flaga);

while(1)
{
if(odb_flaga)
if(ds18b20_ConvertT())
{
sprintf(usart_bufor, "Temp Conversion.");
wyslij_wynik();
while (!wys_flaga);

// Zatrzymuje do czasu zakończenia pomiaru
while(!OneWireReadTimeSlot());

sprintf(usart_bufor, "Read Temp.");
wyslij_wynik();
while (!wys_flaga);

// Odczyt danych z ds18b20
ds18b20_Read(ds18b20_pad);

sprintf(usart_bufor, "Check CRC.");
wyslij_wynik();
while (!wys_flaga);

// Oblicza sumę kontrolną CRC danych odczytanych z ds18b20
for (i = 0, crc =0; i < 9; i++)
crc = _crc_ibutton_update(crc, ds18b20_pad[i]);

// Jeśli suma kontrolna się zgadza,
// pokazuje nowe wyniki pomiaru
if(!crc)
{
sprintf(usart_bufor, "CRC OK!");
wyslij_wynik();
while (!wys_flaga);

// Zmienna "t" zawiera wartość temperatury
t = ((ds18b20_pad[0] >> 1) - 0.25) + (ds18b20_pad[7] - ds18b20_pad[6])/ds18b20_pad[7];

sprintf(usart_bufor, "TEMP: %d", t);
wyslij_wynik();
while (!wys_flaga);
} else
{
sprintf(usart_bufor, "CRC BAD.");
wyslij_wynik();
while (!wys_flaga);
}
odb_flaga = 0;
}
}

return 0;
}[/syntax]

Kod powinien:
-na samym początku przez USART przesłać napis [DZIAŁA]
-po odebraniu sygnału przez USART odpalić pętlę mierzenia temperatury [DZIAŁA]
-wypisać zmierzoną temperaturę [DZIAŁA]
-temperatura mogłaby być poprawna...[NIE DZIAŁA]

Niestety w RealTermie dostaję informację, że temperatura wynosi 3 stopnie...siedzę w podkoszulku i zapewniam Was, że tak nie jest. Płytka jest niedaleko wiatraka od komputera...ale nie dość, że nie wieje centralnie na nią, to jeszcze temperatura również się nie zgadza :P.

Wrzucam jeszcze schemat gdzie widać jak podłączona jest Atmega do zasilania oraz termometru:
Obrazek

------------------------ [ Dodano po: 57 minutach ]

mkk13 napisał(a):

Witam,

Zamiast zakładać własny temat, uznałem że kontynuuję ten, bo bardzo dobrze oddaje i moją sytuację.
Atmega88PA-PU, USART działa i korzystam w celu debug'u. Wykorzystany termometr to DS18S20Z+ od Maxima.
Atmega działa póki co na 1MHz.

Kod wygląda następująco:
(...)

Problem rozwiązałem. O dziwo za szybko zgarniałem temperaturę i termometr nie wyrabiał z zapisem.
Jako że nie jest zasilany pasożytniczo, to mogę nasłuchiwać na porcie, aż oznajmi kiedy zakończy konwersję temperatury.
Zmiana w pliku ds18b20.c:
[syntax=c]char ds18b20_ConvertT(void)
{
if (!OneWireReset()) return 0;

OneWireWriteByte(CMD_SKIP_ROM);
OneWireWriteByte(CMD_CONVERT_T);
// FIX:
SET_IN_ONEWIRE_DDR;
while(!(IS_SET_ONEWIRE_PIN));

return 0xff;
}[/syntax]

Statystyki: Napisane przez mkk13 — 10 sty 2016, o 22:27

]]> 2014-08-23T18:58:56+01:00 2014-08-23T18:58:56+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=92607#p92607 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]>


Namazane ze smarta.

Statystyki: Napisane przez majster — 23 sie 2014, o 18:58

]]> 2014-08-23T18:15:36+01:00 2014-08-23T18:15:36+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=92599#p92599 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]> to mój pierwszy post na forum więc serdecznie wszystkich witam. :)

Mnie do stworzenia termostatu zmusiła sytuacja. Okazyjnie zakupiłem nastoletnią chłodziarkę przemysłową Vestfrost, taka sklepowa lodówka na napoje. Okazało się, że temperatura chłodzenia jest zbyt niska i nawet wbudowany termostat z regulacją nie był w stanie zapewnić oczekiwanych warunków pracy - od 10 do 15°C. Poza tym wentylator wymuszający obieg powietrza pracuje ciągle, co uważam za niedopuszczalne - z uwagi na hałas oraz nieefektywną wymianę powietrza (i ciepła). Stąd pomysł na termostat oparty o mikrokontroler.

Kiedyś miałem styczność z BASCOMem, choć na co dzień działam w PHP. Znalazłem stronę Pana Mirka, kursy Eagla, jeszcze jakieś blogi o mikrokontrolerach. Zamówiłem na aukcji wyświetlacz lcd 128x64 na płytce z Atmega8, wyprowadzeniami do DS18B20 i goldpinami do programatora (ok. 60 zł + wysyłka). Nawet wgrany był wsad pokazujący temperaturę z 4 czujników Dallasa - na początek starczy, czego chcieć więcej? :) Aha... 4 microswitche też są.

Założyłem, że program ma realizować następujące funkcję:
- sprawdzanie temperatury w lodówce,
- włączanie/wyłączanie agregatu w odpowiednim momencie,
- włączanie/wyłączanie wentylatora z opóźnieniem w stosunku do agregatu,
- wyświetlanie temperatury wraz z rysowaniem wykresu (tyle pikseli w lcd nie może się marnować ;)),
- regulacja temperatury maksymalnej i minimalnej (włączającej i wyłączającej agregat),
- regulacja opóźnienia wł/wył. wentylatora,
- wyświetlanie stanu pracy (czy włączony agregat/wiatrak, temp. min, max, aktualna).

Do obsługi wyświetlacza wykorzystałem biblioteki u8g. Debouncing klawiszy znalazłem na blogu o mikrokontrolerach. Szybko okazało się, że 8 kB pamięci to wcale nie jest dużo i dały znać o sobie moje braki w znajomości C. Obecnie program jest "na styk" a chciałbym go jeszcze rozbudować (automatyczna histereza, zapis ustawień w eeprom). Z nieba spadł mi kurs C++ kolegi Mokrowski, po którym jeszcze szczęki nie mogę znaleźć - praca jaką włożył w przygotowanie tutoriali iście tytaniczna. Przyznam bez bicia, że zarejestrowałem się tylko co by te listingi zobaczyć :). Mam nadzieję, że po przepisaniu programu do C++ i uporządkowaniu wszystkiego, wywalczę jakiś wolny kB może dwa :D.

Od razu chciałbym zaznaczyć, że w C jestem początkujący. Ostatni program w tym języku pisałem jakieś 10 lat temu i to na PC. Z uC styczności nie miałem chyba jeszcze dłużej, a i tak był to BASCOMowy Basic. Stąd też prośba - gdyby ktoś z bardziej obeznanych kolegów wychwycił jakieś herezje czy kombinacje alpejskie - będę bardzo wdzięczny za uwagi.

[syntax=c]#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include "u8g.h"

#define KEYBOARD_DEBOUNCE_MS 50 //czas zwloki debouncera w [ms]

#define KEY1_PINPC5 //definicja klawiatury
#define KEY1_PORTPORTC
#define KEY1_PIN_REGPINC
#define KEY1_DIRDDRC
#define KEY2_PINPC4
#define KEY2_PORTPORTC
#define KEY2_PIN_REGPINC
#define KEY2_DIRDDRC
#define KEY3_PINPC3
#define KEY3_PORTPORTC
#define KEY3_PIN_REGPINC
#define KEY3_DIRDDRC
#define KEY4_PINPC2
#define KEY4_PORTPORTC
#define KEY4_PIN_REGPINC
#define KEY4_DIRDDRC

// 1-wire configuration
#define ONEWIRE_PINPD0
#define ONEWIRE_PORTPIND
#define ONEWIRE_DDRDDRD

// DS18S20 commands
#define SKIP_ROM0xCC
#define CONVERT_T0x44
#define READ0xBE

// ports
#define set_LED PORTB |= (1<<PINB5) // -->LED = 1
#define clear_LED PORTB &= ~(1<<PINB5) // -->LED = 0
#define set_AGR PORTD |= (1<<PIND1) // -->AGR = 1
#define clear_AGRPORTD &= ~(1<<PIND1) // -->AGR = 0
#define set_FAN PORTD |= (1<<PIND2) // -->FAN = 1
#define clear_FAN PORTD &= ~(1<<PIND2) // -->FAN = 0


static uint8_t onewire_reset()
{
ONEWIRE_DDR |= (1<<ONEWIRE_PIN);
_delay_us(480);
ONEWIRE_DDR &= ~(1<<ONEWIRE_PIN);
_delay_us(70);
uint8_t ret = ~(ONEWIRE_PORT & (1<<ONEWIRE_PIN));
_delay_us(410);
return ret;
}

static void _onewire_write_bit(uint8_t value)
{
uint8_t sreg = SREG;
cli();
ONEWIRE_DDR |= (1<<ONEWIRE_PIN);
_delay_us(1);
if(value)
{
ONEWIRE_DDR &= ~(1<<ONEWIRE_PIN);
_delay_us(59);
}
else
{
_delay_us(59);
ONEWIRE_DDR &= ~(1<<ONEWIRE_PIN);
}
SREG = sreg;
_delay_us(30);
}

static uint8_t _onewire_read_bit()
{
uint8_t sreg = SREG;
cli();
ONEWIRE_DDR |= (1<<ONEWIRE_PIN);
_delay_us(1);
ONEWIRE_DDR &= ~(1<<ONEWIRE_PIN);
_delay_us(15);
uint8_t ret = ONEWIRE_PORT & (1<<ONEWIRE_PIN);
SREG = sreg;
_delay_us(75);
return ret;
}

static void onewire_write_byte(uint8_t value)
{
for(uint8_t i = 0; i < 8; i++)
{
_onewire_write_bit(value & 0x01);
value = value >> 1;
}
}

static uint8_t onewire_read_byte()
{
uint8_t ret = 0;
for(uint8_t i = 0; i < 8; i++)
{
ret = ret >> 1;
if(_onewire_read_bit()) ret |= 0x80;
}
return ret;
}

volatile uint8_t stan_przyciskow, poprzedni_stan_przyciskow; //4LSB zawieraja informacje o stanie
//przyciskow 1-wcisniety, 0-wolny
volatile uint8_t stable_state[4]; //tablica do szybkich operacji w petli
volatile uint8_t debounce_timer[4]; //tablica do szybkich operacji w petli

void SetupKeyboard (void) { //konfiguracja klawiatury
KEY1_DIR &= ~(1<<KEY1_PIN); //pin przycisku jako wejscie
KEY1_PORT |= (1<<KEY1_PIN); //podciagniecie pinu do VCC
KEY2_DIR &= ~(1<<KEY2_PIN);
KEY2_PORT |= (1<<KEY2_PIN);
KEY3_DIR &= ~(1<<KEY3_PIN);
KEY3_PORT |= (1<<KEY3_PIN);
KEY4_DIR &= ~(1<<KEY4_PIN);
KEY4_PORT |= (1<<KEY4_PIN);
}
void InitDebounceTimer (void) //konfiguracja timera0
{
TCNT0 = 0x1; //zmiana ustawien powinna byc dla wartosci !0xFF i !0x0
TCCR0 |= (1<<CS01); //preskaler = 8 (dla 1[MHz] przepelnienia co 2.048[ms])
TCCR0 &= ~((1<<CS00) | (1<<CS02));
TIMSK |= (1<<TOIE0); //obsluga przerwania od przepelnienia
}


void SetupHardware (void)
{
//ACSR &= ~(1<<ACD); //wylaczenie zbedznie pracujacego ACD
SetupKeyboard();
InitDebounceTimer();
}


ISR(TIMER0_OVF_vect)
{
uint8_t key_value[4]; //tablica wartosci dla klawiatury

//odczyt klawiatury (przycisk: 1->wcisniety, 0-wolny)
if(KEY1_PIN_REG & (1<<KEY1_PIN)) {key_value[0] = 0;} else {key_value[0] = 1;}
if(KEY2_PIN_REG & (1<<KEY2_PIN)) {key_value[1] = 0;} else {key_value[1] = 1;}
if(KEY3_PIN_REG & (1<<KEY3_PIN)) {key_value[2] = 0;} else {key_value[2] = 1;}
if(KEY4_PIN_REG & (1<<KEY4_PIN)) {key_value[3] = 0;} else {key_value[3] = 1;}

for(uint8_t i = 0; i < 4; i++) { //obsluga kazdego przycisku z osobna
if(debounce_timer[i] > 0) { //gdy odmierzanie czasu zwloki
if((--debounce_timer[i] == 0) && (stable_state[i] ^ key_value[i])) {
stable_state[i] ^= 0x1; //aktualizacja stanu klawiatury gdy koniec zwloki
stan_przyciskow ^= (1<<i); //i zmienil sie stan logiczny na wejsciu
}
} else { //skanowanie klawiatury
if(stable_state[i] ^ key_value[i]) { //wykrycie zmiany stanu
debounce_timer[i] = KEYBOARD_DEBOUNCE_MS / 2; //ustawienie czasu zwloki
}
}
}
}




char w_temp[5] ="{0}", w_lo[5] = "{0}", w_hi[5] = "{0}", buf[5] = "{0}", info[22] = "{0}";
float fTemp = 0;
int16_t iTemp = 0, iTemp_lo = 220, iTemp_hi = 230;
uint8_t wykres[66] = {0};
uint8_t switch_agr = 0, switch_fan = 0, opoznienie = 3;
u8g_t u8g;

void draw(void)
{
uint8_t b;

// Wykres i linie graniczne
for (b=1; b<66; b++)
{
if (wykres[b-1]>0) {
u8g_DrawLine(&u8g, b, wykres[b], b-1, wykres[b-1]);
}
if (b%3 == 1 )// Przerywane linie graniczne
{
u8g_DrawPixel(&u8g, b, 62-iTemp_lo/5);
u8g_DrawPixel(&u8g, b, 62-iTemp_hi/5);
}
}

// Oznaczenia temp. na skali pionowej (30, 25, 20, 15, 10, 5 stopni)
u8g_SetFont(&u8g, u8g_font_blipfest_07n);
for (b=5; b<=55; b+=10) {
u8g_DrawStr(&u8g, 70, b, itoa(32-(b/2), buf, 10) );
u8g_DrawLine(&u8g, 67, b-3, 68, b-3);
}

//
u8g_DrawBox(&u8g, 79, 0, 49, 54);//Ciemne tlo pod glowny
u8g_DrawLine(&u8g, 66, 0, 66, 53);//Linia osi pionowej wykresu
u8g_DrawLine(&u8g, 0, 53, 66, 53);//Linia osi poziomej wykresu


u8g_SetColorIndex(&u8g, 0);

// jasny prostokat pod napisem AGREGAT
if (switch_agr == 1)
{
u8g_DrawBox(&u8g, 81, 28, 45, 11);
}

// jasny prostokat pod napisem WIATRAK
if (switch_fan == 1)
{
u8g_DrawBox(&u8g, 81, 41, 45, 11);
}
u8g_SetFont(&u8g, u8g_font_fub17n);
u8g_DrawStr(&u8g, 80, 22, w_temp);
u8g_SetColorIndex(&u8g, 1);
u8g_SetFont(&u8g, u8g_font_6x12r);
u8g_DrawStr(&u8g, 83, 37, "AGREGAT");
u8g_DrawStr(&u8g, 83, 50, "WIATRAK");
u8g_DrawStr(&u8g, 13, 63, info);

}



int main(void)
{
uint8_t i, a, lag_counter = 0;
const char *kropa = ".";
char cTempH = 0, cTempL = 0;

DDRB = 0b11111111;
PORTB = 0b00000000;
DDRD= 0b11111111;
//PORTD = 0b00000000;

sei(); //wlaczenie obslugi przerwan
SetupHardware(); //konfiguracja sprzetu
u8g_InitSPI(&u8g, &u8g_dev_uc1601_c128032_2x_sw_spi, PN(1,2), PN(1,3), PN(1,0), PN(1,1), U8G_PIN_NONE); // inicjalizacja lcd po spi
u8g_Delay(50);

set_LED;
u8g_SetColorIndex(&u8g, 1);

// glowna petla
for(i=0; ; i++)
{
// wykrycie przycisniecia microswitcha
if ( stan_przyciskow != poprzedni_stan_przyciskow)
{
switch( stan_przyciskow )
{
case 0b1:// micro_sw 1zmniejsza temp min o 0.5'C
iTemp_lo -= 5;
break;

case 0b10:// micro_sw 2zwieksza temp min o 0.5'C
//if (iTemp_hi-iTemp_lo > 10)// wylaczone z powodu braku pamieci
iTemp_lo += 5;
break;

case 0b100:// micro_sw 3zmniejsza temp max o 0.5'C
//if (iTemp_hi-iTemp_lo > 10)// wylaczone z powodu braku pamieci
iTemp_hi -= 5;
break;

case 0b1000:// micro_sw 4zwieksza temp max o 0.5'C
iTemp_hi += 5;
break;

// wcisniecie dwoch klawiszy razem zmienia opoznienie
case 0b1100:// micro_sw 3+4
if (opoznienie < 9)
opoznienie ++;
break;

case 0b11:// micro_sw 1+2
if (opoznienie > 1)
opoznienie --;
break;

}

// migniecie podswietlenia lcd sygnalizuje odczyt przycisku
clear_LED;
u8g_Delay(10);
set_LED;
// zmiana licznika petli zeby wskazywal na kolejny cykl odswiezenia wyswietlacza
i += 32-i%32;
} else {
poprzedni_stan_przyciskow = stan_przyciskow;
}

if (i >= 256) {
i = 0;
}

// cykl odczytu temperatury, sterowania i odswiezania wyswietlacza
if ( i % 32 == 0 ) {
// Odczyt temperatury z DS18B20 po 1-wire (jeden czujnik)
onewire_reset();
onewire_write_byte(SKIP_ROM);
onewire_write_byte(CONVERT_T);
u8g_Delay(30);
onewire_reset();
onewire_write_byte(SKIP_ROM);
onewire_write_byte(READ);
cTempL = onewire_read_byte();
cTempH = onewire_read_byte();
fTemp = (float)(cTempL+(cTempH<<8))/16;
// Konwersja odczytanej temperatury
iTemp = fabs(fTemp)*10;// zamiast operacowac na float mnozy temp przez 10 i trzyma wartosc w int
itoa(iTemp/10, w_temp, 10);
strcat(w_temp, kropa);
strcat(w_temp, itoa(iTemp%10, buf, 10));// przeksztalcenie temp do tablicy char "23.5"

itoa(iTemp_lo/10, w_lo, 10);
strcat(w_lo, kropa);
strcat(w_lo, itoa(iTemp_lo%10, buf, 10));

itoa(iTemp_hi/10, w_hi, 10);
strcat(w_hi, kropa);
strcat(w_hi, itoa(iTemp_hi%10, buf, 10));

// Linijka informacyjna
*info = '\0';
strcat(info, "Lo=");
strcat(info, w_lo);
strcat(info, " D=");
strcat(info, itoa(opoznienie, buf, 10));
strcat(info, " Hi=");
strcat(info, w_hi);

// Zapisywanie stanow wykresu w tablicy
if ( i == 32 )
{
wykres[65] = 62-iTemp/5;

if (iTemp >= 315)wykres[65] = 1;
if (iTemp < 50)wykres[65] = 52;

// przesuwanie tablicy
for (a=0; a<65; a++)
{
wykres[a] = wykres[a+1];
}

}

// Wlaczenie agregatu
if ( iTemp >= iTemp_hi ) {
if ( switch_agr == 0 )
{
set_AGR;
switch_agr = 1;
lag_counter = opoznienie*8;
}
}

// Wylaczenie agregatu (opoznienie wylaczenia wentylatora 2x wieksze)
if ( iTemp <= iTemp_lo ) {
if ( switch_agr == 1 )
{
clear_AGR;
switch_agr = 0;
lag_counter = opoznienie*16;
}
}

// Wlaczenie/wylaczenie wentylatora z opoznieniem
if (lag_counter > 1)
{
lag_counter--;
} else {
if (switch_agr == 1)
{
set_FAN;
switch_fan = 1;
} else {
clear_FAN;
switch_fan = 0;
}
lag_counter = 0;
}

// Rysowanie na lcd
u8g_FirstPage(&u8g);
do
{
draw();
} while ( u8g_NextPage(&u8g) );
}

// Ponizsza wartosc ma wplyw na skale czasu wykresu
u8g_Delay(25);

}
}[/syntax]

Obecnie próbuję przetrawić wcześniej wspomniany kurs C++ i przepisać wszystko od nowa, tak jak się to powinno w cpp robić. A propos estetyki kodu - co sądzicie o Ruby w uC? Zawracanie głowy czy warte spróbowania?
Zdaje się, że też wpadłem w ten mikrokompot ;).

Pozdrawiam

Obrazek

Statystyki: Napisane przez ashi — 23 sie 2014, o 18:15

]]> 2014-06-11T16:25:25+01:00 2014-06-11T16:25:25+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=84122#p84122 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]> Będę informował o postępach lub jakiś problemach :)
Nie takie hop siup ten termostat :P

Statystyki: Napisane przez nowak90 — 11 cze 2014, o 16:25

]]> 2014-06-11T15:18:23+01:00 2014-06-11T15:18:23+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=84108#p84108 <![CDATA[Re: Pierwszy bardziej zaawansowany projekcik - Termostat z L]]>
[syntax=c]#include <avr/io.h>
#include <util/delay.h>

//makra z pinami do których podłączone są klawisze
#define KEY1 (1<<PC1)
#define KEY2 (1<<PC2)
#define KEY3 (1<<PC3)

#define PRZYROST 2 //przyrost temperatury w stopniach

//definicje zmiennych globalnych
uint8_t key_lock1, key_lock2, key_lock3;
uint8_t temp_zadana;
uint8_t flaga;

int main(void) {

PORTC |= KEY1 | KEY2 | KEY3; // podciągamy linie klawiszy do VCC

temp_zadan = 23;
// oczekiwanie na ustalenie się stanu wysokiego na wejściu klawisza
_delay_ms(10);

while(1)
{

if( !key_lock1 && !(PINC & KEY1 ) ) //jeżeli klawisz S1 wcisniety
{

key_lock1 = 1; //key_lock1 = 1


}
else if( key_lock1 && (PINC & KEY1 ) ) //jeżeli nie
{
key_lock1++; //to zwiększaj key_lock aż będzie równe 0 - eliminacja drgań styków
flaga = 0; //i ustaw flage na zero
}
else if( key_lock1 && !(PINC & KEY1) ) flaga = 1; // jeżeli key_lock1 > 0 ale klawisz nadal wcisnięty
// ustaw flage na jeden


if (flaga == 1) //jeżeli flaga równa jest jeden co oznacza że S1 wcinięty to
{
if( !key_lock2 && !(PINC & KEY2 ) ) //jeżeli klawisz S2 wciniety zrób przyrost
{//-jednokrotne wcinięcie - pojednczy przyrost

key_lock2 = 1; //eliminacja drgań styków
temp_zadana = temp_zadana + PRZYROST;


}
else if( key_lock2 && (PINC & KEY2 ) ) key_lock2++; //eliminacja drgań styków


if( !key_lock3 && !(PINC & KEY3 ) ) //jeżeli klawisz S3 wciniety zmniejsz przyrost
{////-jednokrotne wcinięcie - pojednczy spadek
key_lock3 = 1; //eliminacja drgań styków
temp_zadana = temp_zadana - PRZYROST;

}
else if( key_lock3 && (PINC & KEY3 ) ) key_lock3++; //elominacja drgań styków

}


}

}[/syntax]

okomentowałem kod, nie kompilowałem ani nie sprawdzałem, to tylko idea. Wydaję mi się że trafna. Być może koledzy z forum polecą Ci lepszą metodę obsługi klawiszy :)

W programie musisz jakoś uwzględnić co chcesz w danej chwili pokazywać. Podowiem Ci tak:

Jak S1 nie wciśnięty jakaś flaga = 0
Jak S1 wciśniety jakaś flaga = 1

jak jakaś flaga = 0 to rób to co masz robić, wyświetlaj temperatur itd.
jak jakaś flaga = 1 to pokazuje na wyświetlaczu aktualnie nastawioną temp i S2 albo S3 ją zwiększaj

trzeba troszkę pomyśleć:)

do funkcji od wyswietlania temperatury możesz dopisać że np:

[syntax=c]uint8_t temp_aktualna; //definicja przed funkcją main jako zmienna globalna

//w funkcji display_temp
temp_aktualna = cel;[/syntax]

a później sprawdzać czy temperatura nastawiona jest mniejsza od odczytanej i:
jeżeli tak to DIODA ON
jeżeli nie to DIODA OFF

oczywiście nie uwzględniam tutaj czy temp jest ujemna czy dodatnia. o tym informuje Cie zmienna subzero którą też możesz wykorzytsać w warunku do gaszenia i zapalnia diodełki:)

to takie moje rozkminy na szybko. Może Ci coś w głowie zaświta:)

Statystyki: Napisane przez Nefarious19 — 11 cze 2014, o 15:18

]]> 2014-06-12T11:13:30+01:00 2014-06-11T11:30:00+01:00 https://forum.atnel.pl/viewtopic.php?t=7390&p=84074#p84074 <![CDATA[Pierwszy bardziej zaawansowany projekcik - Termostat z LCD]]> Postanowiłem zrobić termostat z LCD na czujniku DS18B20. Zmontowałem układ na płytce stykowej (sporządzając wcześniej schemat :) ) i z pomocą książki i CD Pana Mirka odpaliłem magistrale 1WIRE :)
Chciałbym aby za pomocą trzech przycisków dało się nastawić "temperature zadana" Np. trzymając S1 (nastaw) operujemy przyciskami S2 (+) i S3 (-) następnie puszczamy przycisk S1.
Grzałką jest dioda LED która ma się zapalać po spadku temp i wyłączać po jej osiągnięciu (czujnik nagrzewam przez dotkniecie palcem). Później może wzbogacę program o jakaś nastawialną histerezę, ale na razie nie potrzeba.

W tej chwili odczytuje mi ładnie temp, ale nie wiem jak zapisać wartość temperatury i zastosować do niej jakąś arytmetykę. Próbowałem również aby trzymając przycisk S1(nastaw) wyświetlacz
wyświetlał mi inny tekst, ale migotał i był mało czytelny :(
Uda się coś pomóc? Czy jestem zbyt początkujący?

Oto mój schemacik:
Obrazek

I main Pana Mirka który przerobiłem pod siebie:
[syntax=c]#include "lcd44780.h"
#include "ds18x20.h"

void display_temp(uint8_t x);

uint8_t czujniki_cnt;/* ilość czujników na magistrali */
volatile uint8_t s1_flag;/* flaga tyknięcia timera co 1 sekundę */
volatile uint8_t sekundy;/* licznik sekund 0-59 */

uint8_t subzero, cel, cel_fract_bits;

int main(void) {


/* ustawienie TIMER0 dla F_CPU=11,0592MHz */
TCCR2 |= (1<<WGM21);/* tryb CTC */
TCCR2 |= (1<<CS22)|(1<<CS02);/* preskaler = 1024 */
OCR2 = 107;/* dodatkowy podział przez 108 (rej. przepełnienia) */
TIMSK |= (1<<OCIE2);/* zezwolenie na przerwanie CompareMatch */
/* przerwanie wykonywane z częstotliwością ok 10ms (100 razy na sekundę) */
/* do naszych celów nie musi być to bardzo dokładne 10ms */

lcd_init();/* inicjalizacja LCD */

lcd_str("Projekt:");
lcd_locate(1,0);
lcd_str("REGULATOR TEMP.");
_delay_ms(4000);
lcd_cls(); //napis powitalny

/* sprawdzamy ile czujników DS18xxx widocznych jest na magistrali */
czujniki_cnt = search_sensors();


/* wysyłamy rozkaz wykonania pomiaru temperatury
* do wszystkich czujników na magistrali 1Wire
* zakładając, że zasilane są w trybie NORMAL,
* gdyby był to tryb Parasite, należałoby użyć
* jako pierwszego prarametru DS18X20_POWER_PARASITE */
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

/* czekamy 750ms na dokonanie konwersji przez podłączone czujniki */
_delay_ms(1500);

/* dokonujemy odczytu temperatury z pierwszego czujnika o ile został wykryty */
/* wyświetlamy temperaturę gdy czujnik wykryty */
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(1,0);
lcd_str(" error ");/* wyświetlamy informację o błędzie jeśli np brak czujnika lub błąd odczytu */
}


sei();/* włączamy globalne przerwania */

lcd_locate(0,0);
lcd_str_P(PSTR("Temp: xDS18B20")); /* wyświetl napisy w zerowej linii LCD */

/* pętla nieskończona */
while(1) {

if(s1_flag) {/* sprawdzanie flagi tyknięć timera programowego co 1 sekundę */

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 0 sprawdzaj ilość dostępnych czujników */
if( 0 == (sekundy%3) ) {

uint8_t *cl=(uint8_t*)gSensorIDs;// pobieramy wskaźnik do tablicy adresów czujników
for( uint8_t i=0; i<MAXSENSORS*OW_ROMCODE_SIZE; i++) *cl++ = 0; // kasujemy całą tablicę
czujniki_cnt = search_sensors();// ponownie wykrywamy ile jest czujników i zapełniamy tablicę
lcd_locate(0,7);
lcd_int( czujniki_cnt );// wyświetlamy ilość czujników na magistrali
}

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 1 wysyłaj rozkaz pomiaru do czujników */
if( 1 == (sekundy%3) ) DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

/* co trzy sekundy gdy reszta z dzielenia modulo 3 == 2 czyli jedną sekundę po rozkazie konwersji
* dokonuj odczytu i wyświetlania temperatur z 2 czujników jeśli są podłączone, jeśli nie
* to pokaż komunikat o błędzie
*/
if( 2 == (sekundy%3) ) {
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(1,0);
lcd_str(" error ");
}
}

/* zerujemy flagę aby tylko jeden raz w ciągu sekundy wykonać operacje */
s1_flag=0;
} /* koniec sprawdzania flagi */
} /* koniec pętli nieskończonej */
}

/* wyświetlanie temperatury na pozycji X w drugiej linii LCD */
void display_temp(uint8_t x) {
lcd_locate(1,x);
if(subzero) lcd_str("-");/* jeśli subzero==1 wyświetla znak minus (temp. ujemna) */
else lcd_str(" ");/* jeśli subzero==0 wyświetl spację zamiast znaku minus (temp. dodatnia) */
lcd_int(cel);/* wyświetl dziesiętne części temperatury */
lcd_str(".");/* wyświetl kropkę */
lcd_int(cel_fract_bits); /* wyświetl dziesiętne części stopnia */
lcd_str(" C "); /* wyświetl znak jednostek (C - stopnie Celsiusza) */
}


/* ================= PROCEDURA OBSŁUGI PRZERWANIA – COMPARE MATCH */
/* pełni funkcję timera programowego wyznaczającego podstawę czasu = 1s */
ISR(TIMER2_COMP_vect)
{
static uint8_t cnt=0;/* statyczna zmienna cnt do odliczania setnych ms */

if(++cnt>99) {/* gdy licznik ms > 99 (minęła 1 sekunda) */
s1_flag=1;/* ustaw flagę tyknięcia sekundy */
sekundy++;/* zwiększ licznik sekund */
if(sekundy>59) sekundy=0; /* jeśli ilość sekund > 59 - wyzeruj */
cnt=0;/* wyzeru licznik setnych ms */
}
}[/syntax]

Statystyki: Napisane przez nowak90 — 11 cze 2014, o 11:30

]]>