oonko nyt aivan hakoteillä?
oon siis jonkun verran harrastanu plc ohjelmointia työn puolesta ja muutamissa pulssikoodereissa pitää käyttää doublewordiä että saa enemmän tarkkuutta (näissä tapauksissa 16 bittistä)…
mitenkäs avr:ssä? ajan eepromiin tietoa dataloggerissani ja siinä oon pari kertaa miettiny etteikö olis järkeä jättää jakamatta 1024 neljällä että saa sen ajettua eepromiin…
AVR:ssä voi käyttää (u)int16_t tyyppejä. ja 32 onnistuu myös. Niistä tulee sen jälkeen kääntäjän ongelma 
kokonaisluvuista:
http://www.nongnu.org/avr-libc/user-manual/group__avr__inttypes.html
EEPROMin käsittelyyn vihjeitä isommilla otuksilla http://www.nongnu.org/avr-libc/user-manual/group__avr__eeprom.html Ja sinne voi tunkea vaikka mitä jos haluaa.
Olisiko yhtään apua? Ai niin. Käytäthän updatea, etkä writeä? update ei kirjoita jos data on jo oikein muistissa.
writellä ajan ja arduinoa käytän… sinällään vähän hölmösti tein kun sain ex opettajalta tikulla avr kurssin joka jätetty jos pois niin kaiken aineiston jota aloin lukea ja alussa oli että täytyy hommata kehitysalusta… sitte ku aloin katella ni huomasin pääseväni hitusen helpommalla käyttäen arduinoa mutta sitten jäin koukkuun siihen… ehkä pitäis vaan hypätä takasin siihen suoraan rautakieleen kun tuo arduino on niin helppoa tavallaan…
onnistuukos arduinossa käyttää kuitenkin myös noita käskyjä mitä tuossa antamassasi listassa on?
ja mitä tuo block nyt meinaa tuossa? 
oon siis nykysin ensin tehdyn float arvon kertonu sadalla ja sitten jakanu riippuen tiedosta jota ajan muistiin ja luennassa taas kerron sen… mitenkäs tämä flashiin ajaminen nyt käytännössä tapahtuu? niin että bootataan chippi aina että tiedon saa sisälle? 
totesin ehkä eepromin helpoimmaks ensin mutta nyt jo tulossa testikäyttöön suoraan sd-korttipaikka…
oon nyt sen verran hajulla että arduino kuitenkin taitaa olla aika suppea systeemi että ei kuuhun mennä…
Oma mielipide kontrollereila opiskelusta löytyy jostain ketjusta tältäkin foorumilta. lyhyesti todettuna pitää ymmärtää mitä tapahtuu aina ja kokoajan joka koodiriviltä. Silloin elämä on helpompaa. Jos haluaa vain C:ssä pysyä niin sanoisin, että osoitinaritmetiikka on erittäin hyvä ystävä. Sitä voi sitten osatessaan käyttää luovasti väärin.
Itse en ole oikein Arduinoon ihastunut. Voishan sitä, mutta se lankku tarttis ensin hankkia jne… Sillä on hyvät puolet. Se on aloittajaystävällinen, mutta sitten kun mielenkiinto ja kummallisuuksien haluaminen lisääntyy niin sitten se jää auttamatta pieneksi. Ja moni asia, kuten Atmelin rekisterien käpistely jää pois niin mulle ainakin tahtoo tulla virheitä. Esimerkiksi ADC:n kanssa puuhatessa käy ne rekisterit kerran toisensa jälkeen läpi ja kirjoittelee ne arvot paperille niin huomaa monesti, että noinhan sen voisi tehdä paremmin.
Luulisi, mutta arduinolla on omakin kirjasto tuon EEPROMin käsittelyyn. Ja jos se on fiksu niin se käyttää updatea.
Noita käytettäneen jotenkin alla olevan tavan mukaan raakalla raudalla. Arduinolla tehtäneen omilla kirjastoilla eri lailla. Ei ole nyt mitään luntattavaa, mistä näkisi oikean maailman juttuja
void lue_mittaus(uint16_t * kohde); //Funktion esittely. kohde on osoitin tallennuskohteeseen.
uint16_t EEMEM eeprom_kohde[10]; //Varataan tila EEPROMilta.
uint8_t EEMEM joku_kummallinen_tavu = 0x12; //Tuo 0x12 tallennetaan EEPROMille.
/* eeprom_kohde[i] = mittaustulos[i]; ei toimi. tarvitsee käyttää luku ja kirjoituskomentoja.*/
void lue_tallenna(){
uint16_t mittaustulos[10]; //taulukko, johon laitetaan 16-bittisiä mittaustuloksia.
uint8_t i = 0;
uint8_t joku_kummallinen = eeprom_read_byte( & joku_kummallinen_tavu);
for(i = 0; i < 10; i++){
lue_mittaus(& (mittaustulos[i])); //Luetaan mittauksia
joku_viive();
}
eeprom_busy_wait();
eeprom_update_block(mittaustulos, eeprom_kohde, 10 * sizeof(uint16_t));
/* kopioidaan mittaustulos eeprom_kohteeseen. koko on 10 kertaa uint16_t koko.
Noin sen pitäisi toimia.
*/Arduinon IDE:ssähän on jokin polta firmis laitteeseen juttu. AVRdudehan siellä sen sinne kirjoittaa. Ja SD-korttiahan voi arduinon kirjastolla käyttää. Esimerkkejä löytynee netti pullollaan.
Toivottasti vastailin johonkin ongelmaan
osoitinaritmetiikka? 
joo puhdas C on kyllä huomattavasti hankalampilukuista jos on arduinoa ainoastaan käyttänyt… koulussa käytiin binäärit ja hexit läpi joku vuos sitten mutta hexeistä ei mitään muistikuvia enää… ehkä ystävä google auttais kiinnostuksen kohotessa… oppiiko ne sitten kuvittelemaan päässään myös binäärinä/ihan numeroina tai sanoina kun tarpeeks tekee?
ite kun monen moista harrastaneena aina jostain kiinnostuu ni ei meinaa saaha aluks itteensä aiheesta irti ei sitten millään… tämä kyllä todella kiehtova aihe ja elektroniikka yleensäkkin kiehtoo… ikinä ei opi kaikkea ja jos jaksaa tehä niin varmasti joka päivä oppii jotain uutta…
tällähetkellä taas työnpuolesta plc ohjelmointia unitronicsin logiikalla joka ensimmäinen laatuaan miun kohalla… kun taas illat lukee c kielestä ja päivällä on ladderin parissa niin välillä tekee aivot vähän omia johtopäätöksiä
niin se jäi vielä että mikä ero oli sillä Blockilla? Koko kirjoitettu lohko ja nollat lopusta pois?
http://cs.stadia.fi/~silas/ohjelmointi/c_opas-Osoitinm.html Muutenkin ihan hyvä C opastus.
Joo näin vois sanoa. Itselle on kehittynyt päähän kohtuu vahva käsitys seuraavasta taulukosta.
desimaali hex bin
0 0 0000
1 1 0001
2 2 0010
3 3 0011
4 4 0100
5 5 0101
6 6 0110
7 7 0111
8 8 1000
9 9 1001
10 A 1010
11 B 1011
12 C 1100
13 D 1101
14 E 1110
15 F 1111Noita sitten laitetaan peräkkäin niin mielessä syntyy sitten bittikuvio. Ja hex arvo 0x25AF käätyy saman tiem 0010 0101 1010 1111. Enkä tiedä paljonko tuo on desimaaleina. Jotain yhdeksäntuhannen päälle, koska luen binääriä oikealta vasemmalta ykköset kakkoset neloset kasit 16 32 64 128… Aivan samoin kuin desimaaleissa luetaan ykköset kymmenet sadat tuhannet…
Auts. Aivonyrjähdys. Oma opinnäytetyön nimi on Modbus mediamuunnin itsenäisellä logiikalla ja tein jotain tuon tikapuun tapaista sen käyttöön, mutta rikoin monia taiteen sääntöjä. Silä kun jotain tekee niin se on vähän sellainen, että miten tätä miettikään.
Nyt en nää tuota nollat lopusta pois ajatustasi. Se on varmasti omasta sovelluksestasi kumpuavaa.
No tuon blockin idea on kopioida tavaraa isommalti. muistista olevasta osoitteesta, olkoon se vaikka structi, taulukko tai vähän isompi tietotyyppi vaikka float. Ihan mikä vaan joka mahtuu EEPROMille.
void eeprom_update_block (const void *__src, void *__dst, size_t __n)Tuossa __src voi olla vaikka se float, joka on muistaakseni 32-bittinen reaaliluku Atmelissakin. __dst on osoite EEPROMille ja __n on koko. Montako tavua kopioidaan.
Siksi esimerkissäni olin käyttänyt tuota taulukon kokoa * sizeof(taulukon tyyppi). sizeof on operaattori, kuten + - & tai joku muu mitä C tarjoaa. Kääntäjä tulee siihen kohtaan ja katsoopi, että tässä lukee sizeof. Mietinpä hetken ja laitan tuon oikealla puolella olevan otuksen viemän tilan tavuina sen tilalle ja jatkan puuhastelua.
Niin joo. Tuota floatin ja kokonaisluvun elämää en vielä miettinytkään. Eli Float on 32-bittinen reaaliluku. Tarkkuus muistaakseni noin neljä desimaalia.
Jos haluaa niin voi tietenkin käyttää kiinteitäkin juttuja.
struct liukumaton_lukutyyppi{
int32_t kokonaiset;
int32_t osaset; //Ei se varaosaliike vaan desimaaliosat.
}Tuo on 64 bittiä iso möhkäle ja siihen tarvitaan
struct liukumaton_lukutyyppi reaalilu;
reaaliluku.kokonaiset = 3;
reaaliluku.osaset = 154;
struct liukumaton_lukutyyppi EEMEM luonnon_vakion_paikka;
eeprom_update_block ( & reaaliluku, &luonnon_vakion_paikka, sizeof( struct liukumaton_lukutyyppi));Suurin piirtein samaan tulokseen päästään käyttämllä doublea joka myös on 64-bittinen. Eikä tarvitse miettiä miten noita lasketaan. tuo siis tarvitsisi jotain laskufunktioita heti kaveriksi.
Pitäisköhän sinulle suositella http://www.sulautetut.fi/ Ja aiempaa keskustelua http://www.ruuvipenkki.fi/foorumi/viewtopic.php?f=14&t=399, vaikka osaatkin jo jotain niin tuossa oli hyviä ajatuksia.
nyt takasin aiheeseen… piti tehdä lapsi tuossa välissä niin ei joutanu oikeen harrastuksien pariin… 
En vielä päättäny ryhtyä opiskelemaan suoraa C:tä niin katotaan miten arduinon saa muokattua itelle sopivaks? seuraavanlaiset tekstitiedostot löytyy siis eeprom library kansiosta ja veikkaan että niitä muokkaamalla saan tallennettua 16 bittistä matskua atmega328:lle?
eeprom.h
[code]/*
EEPROM.h - EEPROM library
Copyright © 2006 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef EEPROM_h
#define EEPROM_h
#include <inttypes.h>
class EEPROMClass
{
public:
uint8_t read(int);
void write(int, uint8_t);
};
extern EEPROMClass EEPROM;
#endif
[/code]
eeprom.cpp
[code]/*
EEPROM.cpp - EEPROM library
Copyright © 2006 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/******************************************************************************
#include <avr/eeprom.h>
#include “WConstants.h”
#include “EEPROM.h”
/******************************************************************************
/******************************************************************************
/******************************************************************************
uint8_t EEPROMClass::read(int address)
{
return eeprom_read_byte((unsigned char *) address);
}
void EEPROMClass::write(int address, uint8_t value)
{
eeprom_write_byte((unsigned char *) address, value);
}
EEPROMClass EEPROM;
[/code]
vaihtelenko siis näin äkkiseltään vilaistuna vaan “16” noitten “8”:en tilalle? ja “word”, “byte”-sanojen tilalle?
Eipä taida ihan niin vain onnistua, kun eeprommin kirjoitusfunktiot olettavat datan olevan 8 bittistä.
Sen sijaan sinun täytyy lähtödata jakaa kahteen 8 bittiseen muuttujaan ja tallettaa ne (pseudokoodia):
uint16_t data;
uint8_t hi_byte;
uint8_t lo_byte;…
hi_byte = (uint8_t )(data >> 8); // Shiftaa ylimmät bitit alas
lo_byte = (uint8_t )(0x00ff&data); // Maskaa alimmat bitit
myEEPROm.write(address, lo_byte);
myEEPROm.write(address+1, hi_byte);