Counter in C met +/- functie

Hallo,

itoa en de sturing voor de lcd hoef je niet allemaal zelf te gaan ontwikkelen en het wiel opnieuw uit te vinden (hoewel het leerzaam is). Deze functies bestaan al in een library: procyon AVRlib:
http://www.mil.ufl.edu/~chrisarnold/components/microcontrollerBoard/AV…

Verder begrijp ik je probleem niet echt.

Die zipfile op die site doet het niet..

Het probleem zit hem in de void functienamen. De C files kunnen wel onderling communiceren alleen ik kan geen variabelen uit een C file in een ander C file gebruiken naar mijn idee is deze koppeling bij mij incorrect.

Dus bij (display_itoa) moet /signed long nr/ de waarde /kwh_price_total/ overnemen van (count_cost)

[Bericht gewijzigd door Henry S. op vrijdag 11 april 2008 19:05:05 (37%)]

Je kan return gebruiken om je methode een waarde terug te laten geven. Dus geen void methodes gebruiken. Dat is m.i. code technisch de meeste nette manier.

Ook kan je alle benodigde variabelen globaal declareren. Dat werkt efficient (m.b.t. geheugengebruik), maar je code wordt er niet overzichtelijker van.

Ook kan je pointers naar variabelen doorgeven om variabelen buiten de methode te bewerken. Werken met pointers zou ik een beginner niet direct aanraden.

Ik zie overigens hele vreemde bewerkingen in je code. Voorbeeld:

void count_cost(signed long kwh_price_total ,signed short kwh_cnt_neg)
{
//kwh_cnt_pos     = 0;
//kwh_cnt_neg     = 0;
kwh_price_pos   = 25;
kwh_price_neg   = 55;
kwh_price_total = 0;

Waarom kwh_price_total en kwh_cnt_neg meegeven aan deze count_cost methode als vervolgens het eerste wat je doet is deze waarden overschijven?

Op 2 april 2008 19:11:37 schreef Marcel:

Waarom kwh_price_total en kwh_cnt_neg meegeven aan deze count_cost methode als vervolgens het eerste wat je doet is deze waarden overschijven?

Ik dacht dat dit de manier was om variabele waardes mee te geven om deze later weer te gebruiken. Ik zal eens kijken naar die globals.

Dat raad ik je juist af i.v.m. het overzicht van je code. Ga liever voor optie 1. Even een simpele basis:

unsigned int optellen(unsigned int a, unsigned int b)
{
  return a + b;
}

De methode optellen heeft twee variabelen a en b, die worden opgeteld en terug gegeven.
Gebruik is als volgt.

unsigned int x,y,z;
x = 1;
y = 2;
z = optellen(x, y);

z is nu 3

Wel, je geef een waarde terug als output:

int sum(int a, int b){
int c = a+b;
return c;
}

of je geeft het adres van de doelvariabele mee als argument
(google eens op pointers, en doe wat c oefeningetjes met behulp van een c-ontwikkelomgeving, bv dev-c bloodshed)

void sum(int a,int b,int* c){
*c = a+b
}

deze roep je dan op als volgt:
int a = 4;
int b = 6;
int c = 0;
sum(a,b,&c);

of je werkt met globale variabelen, maar dat raad ik je af, omdat je programma heel onoverzichtelijk wordt.
int c;
void sum(int a, int b){
c = a+b;
}

Volgens mij ben je nog niet vertrouwd met call-by-value en call-by-reference, dus heb je wat google werk voor de boeg!

En AVRlib kan je ook hier downloaden (gebruik de installer package)
http://hubbard.engr.scu.edu/embedded/

Haal eens het woordje static weg bij je globale variabelen. Statische variabelen declareer je in functies.

Maar dat is niet het probleem. Je mist kennis over pointers en adressen, en de begrippen call-by-value en call-by-reference.

Argumenten van een functie zijn input variabelen. De waarde van deze argumenten wijzigen in de functie is enkel geldig in de functie zelf. Output van een functie is een output variabele.

Indien je meerdere variabelen wil gaan outputten, geef je hun adressen mee als input variabelen. Dit worden pointers genoemd.

Om call by value en call by reference te begrijpen probeer je volgende eens. De bedoeling is de waarde van a en b te wisselen. Je kan een interessante conclusie vaststellen!

void verwisselCallByValue(int a, int b){
int temp = a;
a = b;
b = temp;
}

void verwisselCallByReference(int* a, int* b){
int temp = *a;
*a = *b;
*b = temp;
}

int main(){
int c = 1;
int d = 2;
verwisselCallByValue(c, d){
printf("Resultaat call by value: c=%i d=%i",c,d);

c = 1;
d = 2; 
verwisselCallByReference(&c, &d){
printf("Resultaat call by reference: c=%i d=%i",c,d);
}

En dit alles zonder globale variabelen te gebruiken!
c en d werden in de main functie gedefinieerd!

[Bericht gewijzigd door Henry S. op vrijdag 11 april 2008 19:05:41 (44%)]

Op 3 april 2008 00:04:55 schreef steenaap:

dus google werk!

Nou in ieder geval totaal geen google werk. Ik weet er al het een en ander vanaf en haal soms wat hulp uit een boek.
Dit boek is een beetje incompleet, maar heb inmiddels al een betere besteld:D.

Je mist kennis over call-by-value en call-by-reference

Correct!! Hier ligt het probleem ook:D

Ik ga verder aan de slag met jullie raad. Bedankt!!

Op 3 april 2008 00:17:02 schreef steenaap:
Haal eens het woordje static weg bij je globale variabelen. Statische variabelen declareer je in functies.

Waar zie je dat eigenlijk? Of bedoel je de locale?

[Bericht gewijzigd door Henry S. op vrijdag 11 april 2008 19:06:41 (21%)]

hoi,

Met mijn uitdrukking google werk maak ik je geen verwijt hoor. Ik heb mezelf een beetje slecht uitgedrukt. Ik bedoel ermee dat je heel wat informatie over deze onderwerpen kan vinden door snel even te googlen.

Ik denk dat je je eerst even in de C-taal moet verdiepen, voordat je de volgende stap naar microcontrollers maakt. Het zal je veel frustraties besparen!

Wanneer je een variabele in een functie declareert, gaat zijn waarde verloren bij het verlaten van de functie. Een statische variabele behoud zijn waarde.

Probeer volgende functie eens uit, en roep hem verschillende malen na elkaar op

int counterNonStatic(int a){
int b = 0;
b = b + a;
return b;
}

int counterStatic(int a){
static int b = 0;
b = b + a;
return b;
}

En waar ik jouw overbodige statics zie:

static signed long 	kwh_cnt_pos;
static signed long 	kwh_cnt_neg;
static signed long 	kwh_price_pos;
static signed long 	kwh_price_neg;
static signed long 	kwh_price_total;

Deze zijn buiten een functie gedeclareerd en zijn dus globale variabelen. Het is dus onnodig deze statisch te maken.

Hmm blijkbaar kom ik er nog niet helemaal uit..

int read_switches(int A, int B){
if (PINC==0X40)
{
A=A+1;
}
else if (PINC==0x80)
{
B=B+1;
}}

void count_cost(){

static signed long 	kwh_price_pos;
static signed long 	kwh_price_neg;
static signed long 	kwh_price_total;

int kwh_cnt_pos;
int kwh_cnt_neg;
kwh_cnt_pos=1;
read_switches(kwh_cnt_pos,kwh_cnt_neg);

kwh_price_pos   = 25;
kwh_price_neg   = 55;
kwh_price_total = 0;

kwh_price_total = (kwh_cnt_pos * kwh_price_pos) -
                  (kwh_cnt_neg * kwh_price_neg);
}

Nu wil dus de waarde van A in kwh_cnt_pos en de waarde van B in kwh_cnt_neg zetten. Zodat er uiteindelijk de waarde van kwh_price_total zich juist aanpast afhankelijk van de input op PinC.

Even voor de duidelijkheid een opzet van het geheel.

Bij de ADD wordt dus gekeken naar de invoer. Dan wordt hiervan de som gemaakt om de totale prijs te berekenen.
Als deze bekent is wordt de ITOA opgeroepen om het getal om te zetten naar losse ascii waardes. Dus van 123 naar een 1, 2, en een 3.

Dat moeten deze losse waardes op het display worden gezet.

[Bericht gewijzigd door Henry S. op vrijdag 11 april 2008 19:07:19 (22%)]

Hoop dat dit helpt, nu zou je jezelf toch zeker moeten kunnen redden!

Een handige library om AVR te programmeren: libc
http://www.nongnu.org/avr-libc/user-manual/index.html

#include <stdlib.h>						//heeft de functie itoa aanwezig (onderdeel van libc)
#include <util/delay.h>					//heeft de delay routine aanwezig


#define F_CPU				1000000UL	// 1 MHz
#define KWH_PRICE_POS		25
#define KWH_PRICE_NEG		55
#define STRINGLENGTH            16

int main(){
	negKwhCount = 0;
	posKwhCount = 0;
	char array[STRINGLENGTH];

	init();

	while (1){	
		_delay_ms(1);
		
		switch (PORTC){
			case 0x40:		posKwhCount += 1;
							break;
			case 0x80:		negKwhCount += 1;
							break;
		}
		
		double price = ( posKwhCount * KWH_PRICE_POS) - ( negKwhCount * KWH_PRICE_NEG);
		
		itoa(price, array, 10);
		display(array);			
	}
}

void init(){
	init_m32();
	display_init();
}

void display(char* text){
	//hier je lcd display dingen
	display_wr_cmnd_byte(0xD0);
    cntr_delay_us_100(1);		
    for(int i = 0; i<STRINGLENGTH;i++){
  	    display_wr_data_byte(text[i]);
    }
}

Indien jij je programmaatje wilt laten werken doe je het volgende:

int read_switches(int* A, int* B){
if (PINC==0X40)
{
*A=*A+1;
}
else if (PINC==0x80)
{
*B=*B+1;
}}

void count_cost(){

static signed long 	kwh_price_pos;
static signed long 	kwh_price_neg;
static signed long 	kwh_price_total;

int kwh_cnt_pos;
int kwh_cnt_neg;
kwh_cnt_pos=1;
read_switches(&kwh_cnt_pos,&kwh_cnt_neg);

kwh_price_pos   = 25;
kwh_price_neg   = 55;
kwh_price_total = 0;

kwh_price_total = (kwh_cnt_pos * kwh_price_pos) -
                  (kwh_cnt_neg * kwh_price_neg);
}

Dit kwh tellertje lijkt op een school opgave, en dan help ik te veel :-/

Nou scheelt dat het geen schoolopgave is.

Ik ben voor mezelf een beetje aan het leren in C. Hiervoor had ik een boek waar niet genoeg in staat maar ik verwacht vandaag of morgen een nieuwe maar ik kon al niet wachtten om er al mee bezig te gaan.

hmm hij loopt direct vast op de

#include <util/delay.h>

Deze file stond niet in de compiler. Inmiddels erin gezet maar blijven zich fouten aanhouden

[Bericht gewijzigd door Henry S. op vrijdag 11 april 2008 19:07:50 (24%)]

Even over static variabelen.

Een variabele in een functie bestaat aleen tijdens die functie. Zodra de functie verlaten wordt, is de variabele weer weg.

int somefunc (int a)
{ 
  int b; 

  b = b + a; 
  return b;
}

werkt niet. De variabele "b" is ongedefinieerd, en kan iedere keer op een andere waarde beginnen. Zet je hier "static" voor de declaratie van "b", dan zorgt de compiler er voor dat hij WEL van de ene aanroep tot de volgende dezelfde waarde houdt.

Dit is de "eigenlijke" betekenis van het woordje static.

De variabele "b" is nu een globale variabele geworden die ALLEEN binnen de functie "somefunc" bereikbaar is.

Dit hebben ze algemeen gemaakt door ook bij globale variabelen het woordje "static" toe te staan. Daar betekent het dan dat de variablee alleen binnen het FILE adresseerbaar is.

int a, c;
static int b, e;
extern int h;

int somefunc (int c, d)
{
   int e, f;
   static int g;
...

Bedenk nu zelf welke variabele wat voor eigenschappen heeft....

Ik heb problemen met de include files. Naar het toevoegen van de libary geeft ie fouten aan in de .h files.

De fouten bevinden zich bij:

extern void abort(void) __ATTR_NORETURN__;

Hier zegt ie dat hij '(' en ')' verwacht. Dit komt op meerdere plaatsen voor.

///////////////////////////////////////////////////////////////

Zo heb even de boel opnieuw geinstalleerd ivm upgrades.

Nu loopt hij iets anders en loopt vast op het volgende punt:

typedef int int8_t __attribute__((__mode__(__QI__)));
typedef unsigned int uint8_t __attribute__((__mode__(__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int uint16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int uint32_t __attribute__ ((__mode__ (__SI__)));

Hier vraagt hij weer op haakjes en punt komma's terwijl de standaard stdint.h file is.

[Bericht gewijzigd door SvenXom op vrijdag 4 april 2008 10:39:04 (56%)]

ok, ik leer ook bij...

Dit hebben ze algemeen gemaakt door ook bij globale variabelen het woordje "static" toe te staan. Daar betekent het dan dat de variablee alleen binnen het FILE adresseerbaar is.

Wat bedoel je hier mee SvenXom?

Hier vraagt hij weer op haakjes en punt komma's terwijl de standaard stdint.h file is.

[Bericht gewijzigd door steenaap op vrijdag 4 april 2008 13:53:21 (24%)]

Het is handig als je even al deze files include in je project. Waarschijnlijk heb je de inttypes nodig.

#include 	"global.h"					#include 	<avr/io.h>
#include 	<inttypes.h>
#include	<util/delay.h>
#include 	<avr/sleep.h>
#include 	<avr/interrupt.h>
#include 	<math.h>
#include	<stdlib.h>
#include 	<string.h>
#include 	<avr/eeprom.h> 

de global.h maak je zelf aan en zet je op dezelfde plaats van je main.c

Sommige includes vereisen dat je enkele zaken defenieert in je global.h. Zo wil delay.h bijvoorbeeld weten wat de frequentie van je kristal is, om uit te kunnen rekenen hoeveel klok counts hij nodig heeft om 1ms delay te kunnen genereren.

#ifndef GLOBAL_H
#define GLOBAL_H


// global AVRLIB defines
#include "avrlibdefs.h"
// global AVRLIB types definitions
#include "avrlibtypes.h"

// project/system dependent defines

// CPU clock speed
#define F_CPU        10000000UL               		// 
#endif

Ik bedoel dat mijn compiler errors aangeeft in de .h files.
Hij loopt echt compleet niet, constant errors.
Ik gebruik de imagecraft ICCAVR.

Ik weet niet of jij de programma's getest? Zoja, kwam jij hierbij errors tegen?

[Bericht gewijzigd door SvenXom op vrijdag 4 april 2008 11:21:19 (11%)]

Ik gebruik avr-gcc (de windows versie: winavr), en de libraries werken perfect. (Ik heb wel eens een bug uit de interrupt.h gehaald in de laatste release.) Ik heb reeds verscheidene projectjes met winavr gerealiseerd, maar met ICCAVR heb ik geen ervaring.

Programmaatje heb ik niet getest, daarvoor ben ik te druk met andere zaken bezig.

Dan ga ik me daar maar eens op storten.

En nog werkt het niet...

Dat is zo'n loze kreet, daar kan niemand je mee verder helpen.

Op 8 april 2008 19:17:57 schreef Marcel:
Dat is zo'n loze kreet, daar kan niemand je mee verder helpen.

hahahahahahahaa

En zo kom je zeker niet verder..
_{(als je al verder wil)}

[Bericht gewijzigd door Technojunk op dinsdag 8 april 2008 19:45:45 (35%)]

Gaat allemaal goed komen.

Zoals ik al eerder gezegd had wacht ik wel ff op me boekiej. En vraag dan weer om raad wanneer nodig;)

Wat ik dus wil maken is het volgende:

Dit werkt helaas nog steeds niet. De bedoeling is dus dat door met een schakelaar input te geven op PINC de waarde van kwh_cnt_pos of kwh_cnt_neg met een waarde van +1 stijgt. Dan moet er gesprongen worden naar de volgende routine waarin de kwh_price_total berekend wordt. Als deze bekend is moet er na de display.c worden gesprongen en moet deze waarde omgezet worden in losse karakters (ITOA functie) en moeten deze geplaatst worden op het scherm.
De compiler die ik gebruik is de ICCAVR Imagecraft. Hierbij werkt stlib.h niet helemaal lekker dus de ITOA lus zal zelf gemaakt moeten worden.

Wat ik nu al heb is het volgende:

Mijn display.c code is: (De initialisatie en schrijven van de karakters op het scherm werkt al wel goed)

// Schrijven naar het display
void display_wr_4lines(void)
{
    {
    if (display_ready == 1)
	{
	drop ();
	}
    display_ready = 0;
   }
}


void display_itoa (signed long nr, unsigned char *str){
	
	//count_cost(&nr);
	nr_tmp = nr;	
	i = 0;
	if (nr_tmp < 0)
	{
	  str[i++] = '-';
	  nr_tmp=-nr_tmp;
	}
	
	for (str_length=1,div=10; (nr_tmp / div) !=0; str_length++,div*=10);
	
	for (pos=0; pos < str_length; pos++)
	{
	  div /= 10;
	  digit = nr_tmp / div;
	  str[pos+i] = digit + '0';
	  nr_tmp -= digit * div;
	}
	str[pos+i] = 0;
}  

int drop(unsigned char *str )
{
char display_line1 [16] ;
char display_line2 [16] ;
char display_line3 [16] ;
char display_line4 [16] ;
 
for (d=0; d<16; d++);  	
str[d]=5   ;
  
	   display_wr_cmnd_byte(0x01);
       cntr_delay_us_100(20);
       	{	
        display_wr_data_byte(display_line1[0]=str[0]+0x30);
        display_wr_data_byte(display_line1[1]=str[1]+0x30);
        display_wr_data_byte(display_line1[2]=str[2]+0x30);
        display_wr_data_byte(display_line1[3]=str[3]+0x30);
        display_wr_data_byte(display_line1[4]=str[4]+0x30);
        display_wr_data_byte(display_line1[5]=str[5]+0x30);
        display_wr_data_byte(display_line1[6]=str[6]+0x30);
        display_wr_data_byte(display_line1[7]=str[7]+0x30);   
        display_wr_data_byte(display_line1[8]=str[8]+0x30);
        display_wr_data_byte(display_line1[9]=str[9]+0x30);
        display_wr_data_byte(display_line1[10]=str[10]+0x30);
        display_wr_data_byte(display_line1[11]=str[11]+0x30);  
        display_wr_data_byte(display_line1[12]=str[12]+0x30);
        display_wr_data_byte(display_line1[13]=str[13]+0x30);
        display_wr_data_byte(display_line1[14]=str[14]+0x30);
        display_wr_data_byte(display_line1[15]=str[15]+0x30);
        cntr_delay_us_100(1);
        }

Mijn main.c code is:

#include <iom32v.h>
#include <macros.h>
#include <stdio.h>
#include "display.h"
#include "init.h"
#include "accu_indicator.h"

//local var
static unsigned short 	j;

int read_switches(int* A, int* B){
if (PINC==0X40)
{
*A=*A+1;
for (j=0; j<10000; j++);	// wacht 5 sec.
}
else if (PINC==0x80)
{
*B=*B+1;
for (j=0; j<10000; j++);	// wacht 5 sec.
}}

void count_cost(int* kwh_price_total){       

static signed long 	kwh_price_pos;
static signed long 	kwh_price_neg;

int kwh_cnt_pos;
int kwh_cnt_neg;
kwh_cnt_pos=1;
read_switches(&kwh_cnt_pos,&kwh_cnt_neg);

kwh_price_pos   = 25;
kwh_price_neg   = 55;
//kwh_price_total = 0;

// PRICE +999999,99
// PRICE +000000,00
// PRICE -999999,99
*kwh_price_total = (kwh_cnt_pos * kwh_price_pos) -
                  (kwh_cnt_neg * kwh_price_neg);
}

// Maken van de wachtlus
void cntr_delay_us_100(unsigned short delay_us_100)
{
  unsigned short e;
  unsigned char  u;
  for (e=0; e<delay_us_100; e++)
  {
    for (u=0; u<22; u++);
  }
}

//Het hoofdprogramma met de subroutines
void main(void)
{ 
  init_m32();
  display_init();
  while (1)
  {	
  cntr_delay_us_100(1);
  read_switches(0,0);
  count_cost(0);
  display_itoa();
  display_wr_4lines();	
  accu_indicator();
  }
}