Svenska ElektronikForumet

Hej!

Jag håller på med en Arduino, Atmega 328. Jag har kopplat upp ett gäng i2c eeprom för att kunna spara ner alla temperaturer som mäts av en tempgivare. Minnena är på 8kbyte styck.

Hur gör jag för att dela upp en Integer på 2st bytes, så att jag kan spara större tal i minnet?

Någon som vet?


//Alexander

Finns säkert bättre sätt men du kan ju alltid läsa en byte och sedan shifta höger 8steg och läsa resten.

> Hur gör jag för att dela upp en Integer på 2st bytes, så att jag kan spara större tal i minnet?

Ett sätt:
Ett annat är att använda pekare, men det är inte rekommenderat eftersom du då måste veta vilken indian som gäller.


EDIT: Ändrade 0xF0 / 0x0F till 0xFF00 / 0x00FF.

bos: misstänker att du menar 0xFF00 resp. 0x00FF

Du har rätt speakman. Jag ändrar.

Tack för svaren!

Säkert en dum fråga, men hur gör man för att återställa till en INT från dom två char?


//Alexander

> Hur gör jag för att dela upp en Integer på 2st bytes, så att jag kan spara större tal i minnet?

Om du delar upp en integer i två delar så kan du normalt bara spara *mindre* tal.
För mig i alla fall är det inte helt klart vad du menar. Ge grna ett exempel på vad du vill göra.

Ranstam skrev:Säkert en dum fråga, men hur gör man för att återställa till en INT från dom två char?

Då går du bakvägen:

Hej!

Min templogger sparar temperaturen varje sekund, i ett externt eeprom. Varje gång temperaturen sparas i eepromet så sparas en variabel på ett av eepromen, som växer med ett varje gång. Talet är altså det samma som hur många värden som är sparade på eepromet. När loggern har läst in 2000värde så är altså denna integer variabel = 2000.

Variebeln används sedan när jag kopplar upp kretsen till datorn för att ta hem värdena. Jag kan då få reda på hur många värden som är sparade, och kretsen vet när den ska sluta skicka värden ur eepromet(värdena raderas aldrig, bara en variabel som håller koll på hur många som finns sparade i minnet). Samma variabel gör också att om temploggern skulle bli strömlös en stund, och får tillbaka strömen sedan så kommer den att komma ihåg var den ska börja spara mätvärdena, så att dom tidigare mätvärdena inte blir överskrivna oavsiktligt.

Som det är nu så skriver programet en INT till en Byte, och följakligen så går programet runt när den har läst in 256 värden.

Jag ska testa med det som bos skrev!

Tackar!

//Alexander


//Alexander

Foortfarande lite oklart...

> Som det är nu så skriver programet en INT till en Byte, och följakligen så går programet runt när den har läst in 256 värden.

Är det alltså *det* som är "problemet" som du frågar om ?
Du har en 8-bitars räknare som inte riktigt räcker till ? Om du vill
hålla reda på fler än 256 värden så får du ha en större räknare
både i koden i ch i EEPROM'et.

Ranstam skrev:Min templogger sparar [...]

Vad är anledningen att du inte tog med denna information från första början?

Problemställningen blir helt annorlunda eftersom det finns hur många faktorer som helst att ta hänsyn till. Vi vet exempelvis inte hur du sparar dina värden på eeprom. Sparas byte för byte eller int för int? Skickar du över en byte i taget, eller två? Klarar eepromet att ta emot två bytes i samma anrop?

Vi vet inte vilka eeprom du använder (mer än "ett gäng i2c eeprom"). Vi vet inte hur ditt schema ser ut. Vi har inte fått se kod som, enligt dig, är orsaken till att räknaren loopar runt i en byte istället för två. Etc. Saknas massor med information.

Bättre kan vara att definiera på rätt sätt: På detta vis kan man komma åt integern som The_One.As_Int
Även som bytes:
The_One.As_Byte[0] & The_One.As_Byte[1]

Vilken som är vad beror sedan på om processorn/kompilern kör med little eller big endian.

Hej

Hoppas du inte tog illa vid dig av frågeställningen Bos, förlåt,det var inte avsiktligt.

Jag ska göra ett nytt försök att förklara lite tydligare.

Jag har en funktion som heter i2c_eeprom_write_byte(i2cadress, minnesplats, värde som ska sparas); Eftersom denna funktion sparar en "byte" och jag vill spara en INT "2-byte", så vill jag kunna göra om en INT till 2st BYTE, och lägga på 2st olika platser i minnet, för att sedan kunna sätta ihop dom igen, och presentera dom i datorn.

Jag kan lägga upp hela programkoden och ett schema över kopplingarna senare ikväll.

Tack för hjälpen!

MVH
Alexander

Icecaps version är den i mitt tycke bästa, men jag brukar typedef'a istället, då det är rätt vanligt att man måste bryta ned multibyte tal till enkelbyte i uP världen.
dvs:
typedef union _WORD{
unsigned int v;
usigned char vi[2];}WORD;

Sedan när jag deklarerar variablerna så blir det

WORD first_uint;

också vidare

För att sedan komma åt dem som en int:
first_uint.v //hela int'en

och som char
first_uint.vi[0] // första byten
first_uint.vi[1] //andra byten


på det sättet kan du enkelt skriva till och läsa från int'en i enbytes format (dvs char) och ändå ha den tillgänglig som en int.

Är du medveten om att ifall EEPROMet klarar 1 miljon skrivningar slits det ut på mindre än 12 dygn ifall det skrivs kontinuerligt 1 gång / sekund?