ATNEL tech-forum 2018-07-22T11:45:07+01:00 https://forum.atnel.pl/feed.php?f=4&t=21022&mode 2018-07-22T11:45:07+01:00 2018-07-22T11:45:07+01:00 https://forum.atnel.pl/viewtopic.php?t=21022&p=210044#p210044 <![CDATA[Re: Dioda RGB i wewnętrzna pamięć EEPROM]]> andrews, wprowadziłem poprawki według Twoich wskazówek i teraz kod działa tak jak sobie założyłem.

Funkcją atoi() chciałem zamienić parametr na liczbę i wpisać ją do struktury, widać musze poczytać na temat tej funkcji, widziałem ją w poradniku i też próbowałem z niej skorzystać. Jednak na działaniach liczbowych nie bardzo :p

Statystyki: Napisane przez Tom92 — 22 lip 2018, o 11:45

]]> 2018-07-21T13:40:16+01:00 2018-07-21T13:40:16+01:00 https://forum.atnel.pl/viewtopic.php?t=21022&p=210021#p210021 <![CDATA[Re: Dioda RGB i wewnętrzna pamięć EEPROM]]>
Tom92 napisał(a):

[syntax=c]// funkcja do zapamiętania koloru
void RGB( uint8_t r, uint8_t g, uint8_t b) {
        char * wsk;
 
        if(0 == r ) {
                ram_cfg.ledr = atoi(wsk);
        }
 
        if(0 == g ) {
                ram_cfg.ledg = atoi(wsk);
        }
 
        if(0 == b ) {
                ram_cfg.ledb = atoi(wsk);
        }
 
        copy_ram_to_eem();
}[/syntax]


Nie analizowałem dokładnie całego kodu, ale to co zauważyłem "na pierwszy rzut oka". Masz wewnątrz funkcji niezainicjowany wskaźnik wsk i zapisujesz go do EEPROM? Raczej to nie zadziała tak jak zakładasz. Wskaźnik będzie zawierał przypadkowe dane. Kompilator nie zgłaszał zastrzeżeń?

W ogóle nie bardzo rozumiem co chcesz zrobić. Po co używasz funkcji atoi()? Po co te warunki? Co tak naprawdę chcesz wpisać do tej struktury? Jeśli chcesz zapisać do EEPROM aktualną zawartość struktury ram_cfg wywal zupełnie tę funkcję RBG() i w jej miejscu użyj od razu funkcji copy_ram_to_eem(), przykładowo:
[syntax=c]//
if (stan==0) // kolor biały
{
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_ON;

// zapamiętaj biały
// zamiast RGB(1,1,1);
copy_ram_to_eem();
}[/syntax]
...a nawet można jej użyć tylko raz, po zakończeniu tych wszystkich instrukcji if.

W pętli głównej, zamiast tego szeregu if'ów lepiej użyć switch. Tak jak jest też będzie działać, ale ze switch będzie czytelniej.
[syntax=c]//
switch(stan)
{
case 0:
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_ON;
break;
case 1:
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_OFF;
ram_cfg.ledb = DLEDB_OFF;
break;
case 2:
// itd.
}

// funkcję copy_ram_to_eem() wystarczy użyć raz
// po zakończeniu instrukcji switch
copy_ram_to_eem();[/syntax]

EDIT:
Jeszcze nie zauważyłem jednej rzeczy. Przykładowo makro DLEDR_ON masz zdefiniowane jako PORTB &= ~LEDR_PIN.
Później używasz zapisu:[syntax=c]ram_cfg.ledr = DLEDR_ON;[/syntax]
Co zostanie rozwinięte przez preprocesor (tak w uproszczeniu) do:[syntax=c]ram_cfg.ledr = PORTB &= ~LEDR_PIN;[/syntax]
Niewykluczone, że to jakoś zadziała, ale nie sądzisz, że to dość dziwny zapis?
Do ustawienia koloru w strukturze używaj raczej wartości liczbowych (0 lub 1, bo zakładam, że nie sterujesz jasnością poszczególnych kolorów) np.:[syntax=c]ram_cfg.ledr = 1;
ram_cfg.ledg = 0;
ram_cfg.ledb = 1;[/syntax]
i dopiero później na podstawie tej wartości zmieniaj stan pinu, tak jak to masz na początku funkcji main().

Statystyki: Napisane przez andrews — 21 lip 2018, o 13:40

]]> 2018-07-21T12:35:25+01:00 2018-07-21T12:35:25+01:00 https://forum.atnel.pl/viewtopic.php?t=21022&p=210020#p210020 <![CDATA[Dioda RGB i wewnętrzna pamięć EEPROM]]>
Po oglądnięciu poradników video Pana Mirka na temat pamięci EEPROM staram się wykorzystać tą wiedzę na kolorowej diodzie RGB. Już od dłuższego czasu staram się napisać program na zestawie uruchomieniowym ATB wraz z ATB SHIELD IO. Założenie działania programu jest takie:
Przyciskiem zmieniać kolory diody RGB oraz wraz z każdą zmianą koloru procesor powinien zapisać dany kolor do pamięci EEPROM, aby po resecie włączył się zapamiętany kolor diody.

Częściowo się to udało. Zmieniam kolory i zapisuje je do pamięci EEPROM, ale podczas resetu nie wszystkie kolory są prawidłowo zapamiętane. Problem jest z kolorem białym, czerwonym i żółtym.

Poniżej zamieszczam kod programu (Nie uporządkowany bo w fazie testów). Jakby ktoś mógł sprawdzić na swoim zestawie i może będzie wiedział o co chodzi:

main.c
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common.h"

/* konfiguracja pinów podłączonej diody LED RGB */
#define LEDR_PIN (1<<PB2)// definicja pinu R
#define LEDG_PIN (1<<PB0)// definicja pinu G
#define LEDB_PIN (1<<PB1)// definicja pinu B
#define DLEDR_OFF PORTB |= LEDR_PIN// makrodefinicja - wyłączenie pinu R
#define DLEDG_OFF PORTB |= LEDG_PIN// makrodefinicja - wyłączenie pinu G
#define DLEDB_OFF PORTB |= LEDB_PIN// makrodefinicja - wyłączenie pinu B
#define DLEDR_ON PORTB &= ~LEDR_PIN// makrodefinicja - załączenie pinu R
#define DLEDG_ON PORTB &= ~LEDG_PIN// makrodefinicja - załączenie pinu G
#define DLEDB_ON PORTB &= ~LEDB_PIN// makrodefinicja - załączenie pinu B

/* konfiguracja pinu podłączonego klawisza */
#define KEY1_PIN (1<<PD5)
#define KEY_DOWN !(PIND & KEY1_PIN)

/* zmienna pomocnicza */
uint8_t key_lock;

// inicjalizacja ustawień fabrycznych w pamięci Flash
const TCFG pgm_cfg PROGMEM = {
LEDR,
LEDG,
LEDB,
};

TCFG eem_cfg EEMEM;// dane w pamięci EEPROM
TCFG ram_cfg;// dane w pamięci RAM

/*----------------------------- główna funkcja programu ---------------*/
int main(void) {

// ****** inicjalizacja *********
DDRB |= LEDR_PIN|LEDG_PIN|LEDB_PIN;// kierunek pinów diody RGB – wyjściowy
//PORTB |= LEDR_PIN|LEDG_PIN|LEDB_PIN;// wyłączenie diody RGB
DDRD &= ~(KEY1_PIN);// kierunek pinu klawisza - wejściowy
PORTD |= KEY1_PIN;// podciągnięcie pinu klawisza do VCC

check_and_load_defaults();// sprawdzenie wartości i załadowanie ich do pamięci ram

// odczyt wartości z pamięci ram
if( ram_cfg.ledr ) DLEDR_ON;
else DLEDR_OFF;
if( ram_cfg.ledg ) DLEDG_ON;
else DLEDG_OFF;
if( ram_cfg.ledb ) DLEDB_ON;
else DLEDB_OFF;

char stan=0;// początkowy stan klawisza

// ****** pętla główna programu *********
while(1) {

// ******* OBSŁUGA KLAWISZA ********
if( !key_lock && !(PIND & KEY1_PIN ) ) key_lock=1;
else if( key_lock && (PIND & KEY1_PIN ) ) {
if( !++key_lock ) {

// reakcja na PUSH_UP (zwolnienie przycisku)
stan++;
if (stan>6) stan=0;// stan może przyjąc wartości od 0 do 6
// *********************************

if (stan==0)// kolor biały
{
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_ON;

// zapamiętaj biały
RGB(1,1,1);
}
else if (stan==1)// kolor czerwony
{
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_OFF;
ram_cfg.ledb = DLEDB_OFF;

// zapamiętaj czerwony
RGB(1,0,0);
}
else if (stan==2)// kolor zielony
{
ram_cfg.ledr = DLEDR_OFF;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_OFF;

// zapamiętaj zielony
RGB(0,1,0);
}
else if (stan==3)// kolor niebieski
{
ram_cfg.ledr = DLEDR_OFF;
ram_cfg.ledg = DLEDG_OFF;
ram_cfg.ledb = DLEDB_ON;

// zapamiętaj niebieski
RGB(0,0,1);
}
else if (stan==4)// kolor fioletowy
{
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_OFF;
ram_cfg.ledb = DLEDB_ON;

// zapamiętaj fioletowy
RGB(1,0,1);
}
else if (stan==5)// kolor żółty
{
ram_cfg.ledr = DLEDR_ON;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_OFF;

// zapamiętaj żółty
RGB(1,1,0);
}
else// kolor błękitny
{
ram_cfg.ledr = DLEDR_OFF;
ram_cfg.ledg = DLEDG_ON;
ram_cfg.ledb = DLEDB_ON;

// zapamiętaj błękitny
RGB(0,1,1);
}
}
}// koniec obsługi klawisza
}// koniec pętli while
}// koniec pętli głównej programu main[/syntax]

common.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common.h"


void copy_eem_to_ram( void ) {
eeprom_read_block( &ram_cfg, &eem_cfg, sizeof(ram_cfg) );
}

void copy_ram_to_eem( void ) {
eeprom_write_block( &ram_cfg, &eem_cfg, sizeof(ram_cfg) );
}

void copy_pgm_to_ram( void ) {
memcpy_P( &ram_cfg, &pgm_cfg, sizeof(ram_cfg) );
}

void load_defaults( void ) {
copy_pgm_to_ram();
copy_ram_to_eem();
}

void check_and_load_defaults( void ) {
uint8_t i, len = sizeof( ram_cfg );
uint8_t * ram_wsk = (uint8_t*)&ram_cfg;

copy_eem_to_ram();
for(i=0; i<len; i++) {
if( 0xff == *ram_wsk++ ) continue;
break;
}

if( i == len ) {
load_defaults();
}

}

// funkcja do zapamiętania koloru
void RGB( uint8_t r, uint8_t g, uint8_t b) {
char * wsk;

if(0 == r ) {
ram_cfg.ledr = atoi(wsk);
}

if(0 == g ) {
ram_cfg.ledg = atoi(wsk);
}

if(0 == b ) {
ram_cfg.ledb = atoi(wsk);
}

copy_ram_to_eem();
}[/syntax]

common.h
[syntax=c]#ifndef COMMON_H_
#define COMMON_H_

#include <avr/eeprom.h>
#include <avr/pgmspace.h>

typedef struct {
uint8_t ledr;
uint8_t ledg;
uint8_t ledb;
} TCFG;

// ustawienia domylne (fabryczne)
#define LEDR 1// kod klawisza podwietlenia
#define LEDG 1// godziny alarmu nr.1
#define LEDB 1// minuty alarmu nr.1

const TCFG pgm_cfg PROGMEM;// dane w pamięci FLASH
extern TCFG eem_cfg EEMEM;// dane w pamięci EEPROM
extern TCFG ram_cfg;// dane w pamięci RAM


void check_and_load_defaults( void );
void copy_eem_to_ram( void );
void copy_ram_to_eem( void );
void copy_pgm_to_ram( void );
void load_defaults( void );

void RGB( uint8_t r, uint8_t g, uint8_t b);

#endif /* COMMON_H_ */[/syntax]

Statystyki: Napisane przez Tom92 — 21 lip 2018, o 12:35

]]>