Card12 mit EVAL-AD5781 verbinden

Ich habe den Text ausgetauscht... leider immer noch kein Signal auf dem 
Oszi zu sehen... jedenfalls kein Sägezahn ;)

Hast du übers WE noch einen Geistesblitz gehabt?

Gruß & THX

Hallo Jochen,

was kommt den raus 0V oder 2,5?

Grüße
Frank

0V! Wieder einmal :( ;)

Hallo Jochen,

kannst Du über printf Werte zurück zum Rechner ausgeben?

Das täte jetzt das suchen vereinfachen ;-)

Grüße
Frank

Kann es sein, dass hier der Wurm drinnen ist?

1

DACValue = (int)(VoltValue / DACStepWidth); /* typeconversion added */

Weil wir ja int mit unsigned long = setzen!

Gruß

Hier habe ich eine Funktion die festen Text ausgeben kann....

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

9

  void sci0_init(void){

10

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

11

    SC0BDL=26; // MCLK/(16*BaudRate)

12

    SC0CR1=0;

13

    SC0CR2=0x0C; //TE+RE enable

14

}

15

16

void sci0_putc(char data){

17

   while ((SC0SR1 & TDRE) == 0){};

18

   SC0DRL = data;

19

}

20

21

void sci0_puts(char* data){

22

   while (*data)

23

       sci0_putc(*data++);

24

}

25

26

void main(void){

27

  sci0_init();

28

  sci0_puts("\n\nHallo ich bin ein String");

29

  sci0_putc(' ');sci0_putc('1');sci0_putc(' ');sci0_putc('2');sci0_putc(' ');sci0_putc('3');

30

31

  while(1);

32

}

Ich müsste aber auch noch eine haben, die eine Variable ausgeben kann... 
da muss ich aber erst suchen...

Du siehst aber schon hier, der Aufwand ist ziemlich groß an Code, der 
für ein einfaches printf nötig ist ;) bei meinem µC!

Gruß

Hallo Jochen,

das ist gelinde gesagt M...!

Ich würde gerne sehen welche Werte bei unseren Berechnungen rauskommen.
Ich mach mir Sorgen das ich mit den Type Castings nen Bock geschossen 
habe ;-)

Irgend eine Idee wie wir da an eine Rückmeldung vom uC kommen können?
Ich vermute das wir auch keinen online debugger haben?

Grüße
Frank

1

//Zeichen ausgeben

2

3

void sci0_putc(char data){

4

   while ((SC0SR1 & TDRE) == 0){};

5

   SC0DRL = data;

6

}

7

8

void sci0_puts(char* data){

9

   while (*data)

10

       sci0_putc(*data++);

11

}

12

13

14

15

//Eingabe

16

sci0_puts("\nBitte Kommando eingeben (muss Doppelpunkt enthalten):");

17

sci0_gets(command);

18

19

20

//Kommando finden hier anhand des ":"

21

while (commandsub != ':'){

22

23

commandsub = command[y];

24

y++;

25

26

}

27

28

29

//Kommando zur Kontrolle nochmals ausgeben

30

sci0_puts("\n\nGefundenes Kommando: ");

31

32

33

x=y-2;

34

35

while(x>=0){

36

37

commandid[z] = command[z];

38

x--;

39

z++;

40

41

}

42

43

sci0_puts(commandid); //Kommandoausgabe

Das würde schon ehr helfen oder? ;)

Hallo Jochen,

so da werden wir wohl ein kleines Testprogramm stricken müssen um eine 
Textausgabe hin zu bekommen.
Mein Problem is jetzt das ich nicht sicher bin wie arrays definiert 
werden.
Das musst Du bitte mal nachschauen und auch ob es eine Bibliothek mit 
einem printf gibt. Das sollte eigentlich in deinen Handbüchern zum 
compiler drin stehen ;-)

Weil wenn, dann können wir so etwas bauen:

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

const double HalfRange = 2.5;

9

const double DACStepWidth = 5 / 0x03ffff;

10

11

12

  void sci0_init(void){

13

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

14

    SC0BDL=26; // MCLK/(16*BaudRate)

15

    SC0CR1=0;

16

    SC0CR2=0x0C; //TE+RE enable

17

}

18

19

void sci0_putc(char data){

20

   while ((SC0SR1 & TDRE) == 0){};

21

   SC0DRL = data;

22

}

23

24

void sci0_puts(char* data){

25

   while (*data)

26

       sci0_putc(*data++);

27

}

28

29

void main(void){

30

  char mycharacterarray[128] /* This should be a 128 characters long array, how to do this properly? */

31

32

  sci0_init();

33

  mycharacterarray = printf("\n Here kommt die 1. Zahl: %f",HalfRange);

34

  sci0_puts(mycharacterarray);

35

  mycharacterarray = printf("\n Here kommt die 2. Zahl: %f",DACStepWidth);

36

  sci0_puts(mycharacterarray);

37

38

  while(1);

39

}

DAS IST SO SICHER NICHT LAUFFÄHIG!!
Jetzt brauche ich deine Hilfe. Schau bitte das DU das array und den 
printf sauber bekommst. Evtl. gibt es auch einen Ersatz für den printf 
;-)

Grüße
Frank

@APW

Du bist irgendwie immer da wenn ich nimmer weiter weis!!
Dank Dir, das hilft mir schon ein Stück weiter!

Grüße
Frank

@APW

nene so ganz falsch liegst Du nicht.
Das mit dem ungetestet tut mir ja auch leid, ich hab halt nix hier zum 
testen ;-)

@ Jochen
Da klauen wir mal die Idee vom APW und ändern die Zeile in:

DACValue = (VoltValue / DACStepWidth);

also das (int) raus. Ist wie ihr beide festgestellt habt aus mehreren 
Gründen Unsinn :-(

Ja ich werde doch langsam alt!


Was macht unser printf Testprogramm?

Grüße
Frank

@APW

hehe, so ähnlich habe ich auch gedacht und habe mir die Woche was zum 
Basteln bestellt ;-)

Wenn ich Anfang Juni für ein par Tage in D bin hoffe ich alles zusammen 
zu haben das ich das Zeugs mitnehmen kann. Wird spannend nach fast 20 
Jahren mal wieder zu basteln ;-)

Grüße
Frank

Sorry war gerade anderweitig beschäftigt!

Diese Änderung hat nichts gebracht:

DACValue = (VoltValue / DACStepWidth);

leider :(

Kannst du mir nochmal sagen was ich jetzt genau nachschauen soll? Das 
mit dem printf meine ich!

Danke

Hallo Jochen,

so nachdem ich mich durch diverse Meetings gequält habe gehen wir wieder 
auf was sinnvolles über ;-)

printf ist eigentlich ein standard C Befehl mit dem texte formatiert in 
ein character array geschrieben werden können.
Ich will jetzt nicht lügen, aber ich meine das printf in der Bibliothek 
"stdio" definiert ist.
Wenn Du da die Definition findest täte mir das schon helfen.

Grüße
Frank

Hallo Jochen,

ich war dann gestern Abend ein bischen fleißig und habe mal nachgelesen 
was ich finden konnte. Dem zufolge sollte unser Testprogramm für die 
Ausgabe so aussehen:

Was hängt an SCI0 um den Text anzuzeigen?
Kannst DU das bitte mal testen ob wir so eine Anzeige bauen können?
Damit hätten wir dann wenigsten ein wenig debugging zur Verfügung.

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

const double HalfRange = 2.5;

9

const double DACStepWidth = 5 / 0x03ffff;

10

11

12

  void sci0_init(void){

13

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

14

    SC0BDL=26; // MCLK/(16*BaudRate)

15

    SC0CR1=0;

16

    SC0CR2=0x0C; //TE+RE enable

17

}

18

19

void sci0_putc(char data){

20

   while ((SC0SR1 & TDRE) == 0){};

21

   SC0DRL = data;

22

}

23

24

void sci0_puts(char* data){

25

   while (*data)

26

       sci0_putc(*data++);

27

}

28

29

void main(void){

30

  char mycharacterarray[128]; /* This is a 128 characters long array */

31

32

  sci0_init();

33

  sprintf(mycharacterarray,"\n Here kommt die 1. Zahl: %f",HalfRange);

34

  sci0_puts(mycharacterarray);

35

  sprintf(mycharacterarray,"\n Here kommt die 2. Zahl: %f",DACStepWidth);

36

  sci0_puts(mycharacterarray);

37

38

  while(1);

39

}

Grüße
Frank

1

2

Here kommt die 1. Zahl: 2.5                                           

3

Here kommt die 2. Zahl: 0

Bis auf Here passt es :) ;)

Gruß

Wie gehen wir jetzt weiter vor? Was soll ich bei dem anderen Programm 
ausgeben? ;)

Danke

COOOOOL!!!

Ok das mit dem Here ist meinem Job geschuldet.
Programmschnipsel basteln und gleichzeitig hier mit den Jungens englisch 
reden gibt dann so ein Misch Masch :-D

So die 2. Zahl schockiert mich.
Da hätte ich was anderes erwartet ;-)

Ich denke damit haben wir den Fehler schon eingefangen.
Ändere bitte mal in unserem Ausgabe Testprogramm:

const double DACStepWidth = 5 / 0x03ffff;

zu

const double DACStepWidth = 0.00001907;

und noch mal rennen lassen ;-)

So....

Hier jetzt die Ausgabe:

1

2

Hier kommt die 1. Zahl: 2.5                               

3

Hier kommt die 2. Zahl: 0.000019

2. Zahl? Zu kurz! ;)

Here ist zu Hier ausgebessert ;)

Gruß

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

const double HalfRange = 2.5;

9

const double DACStepWidth = 0.00001907;

10

11

12

  void sci0_init(void){

13

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

14

    SC0BDL=26; // MCLK/(16*BaudRate)

15

    SC0CR1=0;

16

    SC0CR2=0x0C; //TE+RE enable

17

}

18

19

void sci0_putc(char data){

20

   while ((SC0SR1 & TDRE) == 0){};

21

   SC0DRL = data;

22

}

23

24

void sci0_puts(char* data){

25

   while (*data)

26

       sci0_putc(*data++);

27

}

28

29

void main(void){

30

  char mycharacterarray[128]; /* This is a 128 characters long array */

31

32

  sci0_init();

33

  sprintf(mycharacterarray,"\n Hier kommt die 1. Zahl: %lf",HalfRange);

34

  sci0_puts(mycharacterarray);

35

  sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl: %lf",DACStepWidth);

36

  sci0_puts(mycharacterarray);

37

38

  while(1);

39

}

Ich habe %f zu %lf noch ausgebessert ;) Aber an der Ausgabe ändert sich 
nichts :(

Leider :(

Hallo Jochen,

das ist um klassen besser als das Ergebnis vorher!!

So ich grübel mal ne runde warum die Zahl zu kurz wird!
Auch wie wir das Problem umgehen können muss ich noch rausfinden ;-)

Du baust bitte die geänderte const Zeile in das DAC Programm und machst 
auf verdacht mal einen Test.

Dann schauen wir weiter

Grüße
Frank

Hallo!

Tataaaaa! Wir haben den Sägezahn!!!! Ich werde nun einmal die Taktrate 
erhöhen. ;)

Danke!

Na das ist doch mal ein Wort ;-)

und APW war mal wieder schneller als ich mit der Lösung.
APW ich werde langsam ein wenig neidisch ;-)

Jochen, kannst Du bitte mal APWs Lösungsvorschlag für die const Zeile 
testen?

Grüße Frank
P.S. APW, Jochen, danke für die Geduld die ihr habt. Hab ja nu doch 
einige Böcke geschossen in den letzten Tagen ;-)

Hey!

1

#include <stdio.h>

2

#include <mc912d128.h>

3

4

5

const double HalfRange = 2.5;

6

const double DACStepWidth = 5.0 / 0x03ffff;

7

8

9

10

void mySPITrans(unsigned char myValue) /*Transmit Byte via SPI*/

11

{

12

  unsigned char mydelete; /* was zum Datenauslesen und verwerfen */

13

14

  SP0DR = myValue; /* Data goes to SPI data register*/

15

  while ((SP0SR & 0x80) == 0); /* wait for transfer to finish */ 

16

  mydelete = SP0DR; /* Daten auslesen und verwerfen */

17

}

18

19

void VValueTo18BitDAC(double VoltValue)

20

{

21

  unsigned long DACValue = 0;

22

  unsigned char mylowbyte = 0x00;

23

  unsigned char mymidbyte = 0x00;

24

  unsigned char myhighbyte = 0x00;

25

26

  DACValue = (VoltValue / DACStepWidth); /* typeconversion added */

27

28

  DACValue = DACValue << 2;  /* shift 2 needed Position in 24Bit Value */

29

30

  mylowbyte = DACValue & 0xff; /* Low Byte preparation */

31

  DACValue = DACValue >> 8; /* shift the next Byte into position */

32

  mymidbyte = DACValue & 0xff; /* Mid Byte preparation */

33

  DACValue = DACValue >> 8; /* shift the next Byte into position */

34

  myhighbyte = DACValue & 0xff; /* High Byte preparation */

35

36

  myhighbyte &= 0x07; /* make sure left 5 bits are empty */

37

38

  if (VoltValue <= HalfRange) /* Check for Halfrange */

39

  {

40

    myhighbyte |= 0x08;   /* to be able to set the MSB */

41

  }

42

43

  myhighbyte |= 0x10;  /* The Data Register Address Bit */

44

45

  PORTS &= ~0x80;  /* /SS output low */

46

  mySPITrans(myhighbyte); /* Analog Value Byte1 MSB first        */

47

  mySPITrans(mymidbyte); /* Analog Value Byte2 24 bit total    */

48

  mySPITrans(mylowbyte); /* Analog Value Byte3 LSB last         */

49

  PORTS |= 0x80;    /* /SS output high */

50

}

51

52

main()

53

{ 

54

  int i = 1;

55

  double myVValue = 0;  

56

57

  /* Init for SPI Interface */

58

  PORTS |= 0x80;

59

  DDRS = DDRS | 0xF0; /* outputs */

60

  SP0CR1 = 0x58; /* 0b01011000 */

61

  SP0CR2 = 0; /* Normal mode */

62

  SP0BR = 0x02; /* 1,0 MHz SPI clock */

63

64

  /* Init to the DAC */

65

  PORTS &= ~0x80;  /* /SS output low */

66

  mySPITrans(0x20); /* Init DAC Control Register Byte1 MSB first      */

67

  mySPITrans(0x00); /* Init DAC Control Register Byte2 24 bit total  */

68

  mySPITrans(0x02); /* Init DAC Control Register Byte3 LSB last       */

69

  PORTS |= 0x80;    /* /SS output high */

70

71

  while (i>0) /* Endles Data sending for testing only */

72

  { 

73

    VValueTo18BitDAC(myVValue);

74

    myVValue += DACStepWidth;

75

    if (myVValue > 5)

76

      myVValue = 0;

77

  }

78

79

  return 0;    

80

}

Das Programm sieht nun folgendermaßen aus. Es läuft schon! Also Danke 
APW ;)

Und Frank was heißt da Danke für die Geduld... ich habe bisher Danke zu 
sagen ;)

Nun werde ich noch den Takt erhöhen :)

Hallo Jochen,

kannst DU noch mal die von APW kommende Ausgabezeile testen?

sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl: 
%2.10f",DACStepWidth);

nur das wir sicher gehen das wir keine "genauigkeit" verlieren ;-)

Tja und danach musste uns sagen was wir als nächstes machen. Weil dann 
rennt der DAC wie gewünscht ;-)

Grüße
Frank

Ich habe nun den SPI-Clock auf 4 Mhz erhöht.... jedoch ist die Ausgabe 
mir dann etwas spanisch^^

Wisst ihr woran das liegt?
Das: sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl:
%2.10f",DACStepWidth); werde ich anschließend einmal testen ;)

Danke!

Hallo Jochen,

Du meinst weil der nicht schneller geworden ist?
Ich bin mir nicht sicher welche Takt der Prozessor selber hat, aber das 
sind jetzt einige Schritte wo er durchrechnen muss um durch zu kommen.
Kann es sein das der SPI mit 4Mhz nicht mehr das begrenzende Element 
ist?

Ist jetzt nur mal ein Verdacht.

Grüße
Frank

Frank Sander schrieb:
> Hallo Jochen,
>
> Du meinst weil der nicht schneller geworden ist?
> Ich bin mir nicht sicher welche Takt der Prozessor selber hat, aber das
> sind jetzt einige Schritte wo er durchrechnen muss um durch zu kommen.
> Kann es sein das der SPI mit 4Mhz nicht mehr das begrenzende Element
> ist?
>
> Ist jetzt nur mal ein Verdacht.
>
> Grüße
> Frank

Du meinst also, dass es der DAC ist? Weil der µC kann es ja net mit 8 
Mhz sein ;) oder?? :)

1

Hier kommt die 1. Zahl: 2.5                                                  

2

Hier kommt die 2. Zahl: 0.000019

Programm dazu:

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

const double HalfRange = 2.5;

9

const double DACStepWidth = 5.0 / 0x03ffff;

10

11

12

  void sci0_init(void){

13

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

14

    SC0BDL=26; // MCLK/(16*BaudRate)

15

    SC0CR1=0;

16

    SC0CR2=0x0C; //TE+RE enable

17

}

18

19

void sci0_putc(char data){

20

   while ((SC0SR1 & TDRE) == 0){};

21

   SC0DRL = data;

22

}

23

24

void sci0_puts(char* data){

25

   while (*data)

26

       sci0_putc(*data++);

27

}

28

29

void main(void){

30

  char mycharacterarray[128]; /* This is a 128 characters long array */

31

32

  sci0_init();

33

  sprintf(mycharacterarray,"\n Hier kommt die 1. Zahl: %lf",HalfRange);

34

  sci0_puts(mycharacterarray);

35

  sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl: %lf",DACStepWidth);

36

  sci0_puts(mycharacterarray);

37

38

  while(1);

39

}

nicht, dass wir wieder aneinander vorbei reden ;) :)

Danke!

Scheint aber zu stimmen was APW da macht!

Hallo Jochen,

8Mhz hat der HC12?
Dann haben wir seine Grenze erreicht.

Ich stelle mal ein par Behauptungen auf:
der HC12 braucht 2 Taktzyklen / Befehl (das erscheint mir optimistisch)
damit kann der HC12 effektiv nur 4 Mhz umsetzen.
Jetzt brauchen wir aber schon 3 Befehle um nur 1 byte von 3 an den DAC 
zu schicken.
Gibt (wieder optimistisch) 9 Befehle. Dann boste schon bei ca. 0,5 Mhz 
oder 500kHz.

Das bedeutet:
Ohne das wir auch nur einen Wert berechnet haben und ohne die reine 
Übertragungszeit des SPI braucht der Prozessor schon 0,5s für einen 
Zyklus.

Wenn Du jetzt noch das ganze grechne da drauf packst und die 
Übertragungszeiten....


Grüße
Frank

Hmmm okay! Das stimmt. Dann muss ich mal sehen, ob das für unsere Zwecke 
reicht... also brauche ich faktisch für jeden Wert an den DAC 0,5 s 
mindestens?!

Hallo Jochen,

ne bei dem Test der Ausgabe meinte ich das wir mal

1

  sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl: %2.10f",DACStepWidth);

testen sollten. nur um zu sehen ob da was vom Wert abgeschnitten wird

Grüße
Frank

Hallo Jochen,

nein nicht für jeden Wert. Das sind dann die ca 262000 werte welche 
Dufür einen Sägezahnzyklus brauchst

Grüße
Frank

Aber du hast doch gesagt die 9 Befehle brauchen schon 0,5 s ??? Oder?? 
Wobei??? Dann kann des Oszi Bild nicht stimmen ^^ Aber alle Werte des 
Sägezahns brauchen auch mehr wie 0,5 s! :)

Du kannst die Maximale Rate mit dem Oscar genau ausmessen.
Änder unser Sägezahn Programm dahingehend, das Du zwischen 0 und 5V 
springst.
Damit bekommst DU am Oscar die Maximal mögliche Änderungsfrequnz 
dargestellt ;-)

Hallo Jochen,

ok dann die Erkläsrung noch mal anders und ein wenig genauer:

Wir führen (dieses mal habe ich nachgezählt) 22 C Zeilen aus um einen 
Wert zu schreiben.

Wenn wir behaupten das jede Zeile 2 Taktzyklen im HC12 sind (viel zu 
optimistisch) dann sind wir bei einer Bearbeitungszeit von 8Mhz / 44 
Zyklen = 0,18 Mhz
Das sind also ca. 0,000005 s pro Wert.

Wir verschicken pro Sägezahnzyklus 262143. Das ergibt dann schon 1,5 
sec.

Das deckt sich nicht mit deinem Bild, weil meine angenommen 2 Taktzyklen 
VIEEEEEEL zu optimistisch sind.

Mach ruhig mal den o.g. Versuch mit den Wertsprüngen zwischen 0 und 5 
Volt, damit wissen wir dann genau was bestenfalls möglich ist ;-)

Grüße
Frank

1

Hier kommt die 1. Zahl: 2.5                                              Hier kommt die 2. Zahl: 0.000019

Dies gibt das Programm aus:

1

#include <stdio.h>

2

3

#include <mc912d128.h>

4

5

#define RDRF 0x20   // Receive Data Register Full Bit

6

#define TDRE 0x80   // Transmit Data Register Empty Bit

7

8

const double HalfRange = 2.5;

9

const double DACStepWidth = 5.0 / 0x03ffff;

10

11

12

  void sci0_init(void){

13

    SC0BDH=0;  // 19200 BR=26 (MCLK=8MHz)

14

    SC0BDL=26; // MCLK/(16*BaudRate)

15

    SC0CR1=0;

16

    SC0CR2=0x0C; //TE+RE enable

17

}

18

19

void sci0_putc(char data){

20

   while ((SC0SR1 & TDRE) == 0){};

21

   SC0DRL = data;

22

}

23

24

void sci0_puts(char* data){

25

   while (*data)

26

       sci0_putc(*data++);

27

}

28

29

void main(void){

30

  char mycharacterarray[128]; /* This is a 128 characters long array */

31

32

  sci0_init();

33

  sprintf(mycharacterarray,"\n Hier kommt die 1. Zahl: %lf",HalfRange);

34

  sci0_puts(mycharacterarray);

35

  sprintf(mycharacterarray,"\n Hier kommt die 2. Zahl: %2.10f",DACStepWidth);

36

  sci0_puts(mycharacterarray);

37

38

  while(1);

39

}

Das Ergebnis ist aber zu oben identisch.... Bringt es also dann jetzt 
den von dir gewünschten Erfolg?

Gruß

Hallo Jochen,

das bestätigt ein wenig meine Sorge.
Ich werde da noch mal lesen müssen ;-)

Generell haben wir aber jetzt ein funktionierendes Programm.
Die "Ungenauigkeit" werden ich noch mal genauer studieren, soll uns aber 
nicht davon abhalten das wir erst mal weiter basteln.

Kannst Du den Test zur maximal darstellbaren Frequenz durchführen?

Grüße
Frank

Nach dem Mittag-Essen ;)

Bis dann

Cu

APW du rettest meinen Tag!!

den %e habe ich gesucht und nicht gefunden!!
Ich gehe derzeit davon aus das wir einem Rundungsfehler zum Opfer 
fallen.

Da ich aber gerade an eben der Vermeidung der double Berechnungen 
arbeite (jep mir ist bewusst das die Dinger richtig Zeit kosten) werde 
ich auf dem Weg auch den Rundungsfehler los.

Ich stimme Dir übrigens zu was die 2 Zyklen betrifft. Habe derweil mal 
ein wenig im Netz gestöbert. Da sprach sogar jemand von 4 Zyklen im 
Mittel (bei Assembler code).
Ob ob Jochen aber wirklich viel schneller werden muss wird er uns noch 
verraten müssen ;-)

Dank Dir erst mal.

Grüße
Frank

Geschwindigkeit ist für mich ziemlich wichtig! Aber ich werde als erstes 
jetzt mal den Test vom Frank programmieren ;)

Und mal messen wie schnell wir momentan sind!

Hier die Messungen. Als Takt habe ich 4,0 Mhz am SPI.

Das Programm:

1

 while (i>0) /* Endles Data sending for testing only */

2

  { 

3

    VValueTo18BitDAC(myVValue);

4

    myVValue = 5;

5

    VValueTo18BitDAC(myVValue);

6

      myVValue = 0;

7

  }

Um Missverständnisse zu beseitigen ;)

:)

Jetzt ^^

Sorry... die Arbeit ;)

Hallo Jochen,

lese ich das richtig?
Von der fallenden Flanke zur fallenden Flanke ca. 450us?

Kannst Du mir sagen wie schnell Du es brauchst?

Grüße
Frank

Ist das jetzt schnell? Also ihr habt ja da mehr Erfahrung wie ich... was 
µC betrifft! ;)

Für meine Zwecke reicht es :) **freu**

Nächste Schritte sollen dann sein, mehrere DACs an einem µC zu 
betreiben. SPI-BUS soll dazu verwendet werden. Hardware habe ich aber 
noch nicht :)

Die Frage die ich deswegen habe ist, was passiert wenn der µC sein 
Signal vom DAC abzieht... das heißt hält der DAC dann seinen Wert? Soll 
nämlich so werden, damit mehrere DACs gleichzeitig laufen können.

Danke!

Hallo Jochen,

leider hast Du die Frage nicht ganz beantwortet ;-)
Wie schnell (je DAC) brauchst Du es denn??

Über wie viele DACs reden wir?

Ich fange gerade an mir Sorgen zu machen ;-)

Grüße
Frank

Hallo APW,

wie viele Beiträge haben wir denn bis jetzt?
evtl. sollten wir dann demnächst einen neuen Fred aufmachen.
Die eigentliche Aufgabe (siehe Überschrift) haben wir ja gelöst ;-)

Grüße
Frank

Ich kann darüber auch noch keine genaueren Angaben machen... ist bei mir 
auch alles noch im Aufbau und muss ich erst einmal selber abklären.... 
;)

Aber nochmal zu dem was ich meinte... wenn ich jetzt über den BUS sagen 
wir 4 DACs ansteuere... dann kann ich ja immer nur eine mit den 
entsprechenden Infos versorgen... wegen dem BUS... und wie ist das dann 
mit den übrigen DACs die nicht SS mäßig gerade angesprochen werden? 
Schalten die sich dann einfach auf 0 V oder halten die ihren vorher 
übermittelten Wert? Das meine ich! Klar? :) ;)

Thx!

Hallo Jochen,

heute wird die Session etwas holperig, weil wir hier auf der Baustelle 
versuchen einen 35KV Traffo scharf zu schalten.
Genauer der Kunde versucht das ;-)

Zu deiner Frage:
der DAC hält die Spannung am Ausgang.
Das kannst Du auch schon an unseren Sägezahnversuchen sehen. Weil wir ja 
immer nach dem Übertragen den SS wegnehmen ;-)

So ich hol mir schnell nen Kaffee und dann kommt die Antwort zu den 
Geschwindigkeiten ;-)

Grüße
Frank

35 kV nicht schlecht ;) Bin zwar kein Energietechniker aber hört sich 
doch beachtlich an... was fließen da für Ströme? ;)

Gruß

Hallo Jochen,

jetzt mal zu den Geschwindigkeiten oder "sample rates".

Es gibt da kein schnell oder langsam. Es gibt nur eine Anforderung die 
mit der gewählten Plattform erfüllt werden kann oder eben nicht.

Einfaches Beispiel:
wenn Du einen 2 Mhz Rechteck mit deiner gewählten Plattform darstellen 
willst, wirst du feststellen das geht nicht. egal wie Du es 
programmierst. Da ist dann der SPI Takt = 4Mhz zusammen mit dem 24 bit 
Kontrollwort eine Physikalische Grenze ;-)

Um also sagen zu können ob und wie deine Idee umsetzbar ist, müssen wir 
erst mal wissen welche Voraussetzungen wir erfüllen müssen.

Wir kennen aber schon ein par Werte die wir schaffen können.

1. Die reine Übertragung eines Wertes dauert 6us (dank an APW)
2. Derzeit verbraten wir durch Rechnereien ca. 220us pro Wert.

Diese 220us können (und müssen??) wir optimieren, nur dafür müssen wir 
wissen auf was wir optimieren. Da kommen dann wieder die schon mal 
gestellten Fragen zum tragen.

Ein einfaches Beispiel:
Ich glaube das wir locker 100us sparen können wenn der "Bediener" die 
Spannung nicht in V sonder in uV angibt.
Dadurch können wir die doubles weg optimieren und die kosten richtig 
Zeit!!

Wie APW schon sagte: Wenn Du nur eine Wertänderung alle 0,5s brauchst 
dann brauchen wir gar nix optimieren und sind (fast) fertig ;-)

Alles klar soweit?

Grüße
Frank

Hallo Jochen,

ich hoffe heute fließen keine Ströme :-D
Aber wenn es mal rennt sind es einige Megawatt die da verbrannt werden 
;-)
Das alles nur um irgendwelche dusseligen Steine durch die Gegend zu 
kutschieren.

Grüße
Frank

Hallo Jochen,

so da ich gerade mal eine kurze Verschnaufoasue habe kommt hier ein 
Programm wo ich mal versuche auf Leufzeit zu optimieren:
Ich habe die doubles durch unsigned long ersetzt. damit wir trotzdem 
noch ausreichend genau rechnen musste ich dafür die Basiswert mit 
1000000 mutliplizieren.

ACHTUNG der SPI Takt steht noch auf 1 MHz ;-)
(glaube ich)

1

#include <stdio.h>

2

#include <mc912d128.h>

3

4

const unsigned long HalfRange = 2500000;

5

const unsigned long DACStepWidth = 5000000 / 0x03ffff;

6

7

void mySPITrans(unsigned char myValue) /*Transmit Byte via SPI*/

8

{

9

  unsigned char mydelete; /* was zum Datenauslesen und verwerfen */

10

11

  SP0DR = myValue; /* Data goes to SPI data register*/

12

  while ((SP0SR & 0x80) == 0); /* wait for transfer to finish */ 

13

  mydelete = SP0DR; /* Daten auslesen und verwerfen */

14

}

15

16

void VValueTo18BitDAC(unsigned long VoltValue)

17

{

18

  unsigned long DACValue = 0;

19

  unsigned char mylowbyte = 0x00;

20

  unsigned char mymidbyte = 0x00;

21

  unsigned char myhighbyte = 0x00;

22

23

  DACValue = VoltValue / DACStepWidth; 

24

25

  DACValue = DACValue << 2;  /* shift 2 needed Position in 24Bit Value */

26

27

  mylowbyte = DACValue & 0xff; /* Low Byte preparation */

28

  DACValue = DACValue >> 8; /* shift the next Byte into position */

29

  mymidbyte = DACValue & 0xff; /* Mid Byte preparation */

30

  DACValue = DACValue >> 8; /* shift the next Byte into position */

31

  myhighbyte = DACValue & 0xff; /* High Byte preparation */

32

33

  myhighbyte &= 0x07; /* make sure left 5 bits are empty */

34

35

  if (VoltValue <= HalfRange) /* Check for Halfrange */

36

  {

37

    myhighbyte |= 0x08;   /* to be able to set the MSB */

38

  }

39

40

  myhighbyte |= 0x10;  /* The Data Register Address Bit */

41

42

  PORTS &= ~0x80;  /* /SS output low */

43

  mySPITrans(myhighbyte); /* Analog Value Byte1 MSB first        */

44

  mySPITrans(mymidbyte); /* Analog Value Byte2 24 bit total    */

45

  mySPITrans(mylowbyte); /* Analog Value Byte3 LSB last         */

46

  PORTS |= 0x80;    /* /SS output high */

47

}

48

49

main()

50

{ 

51

  int i = 1;

52

  unsigned long myVValue = 0; /* changed to float as we do not need 64bit from double */  

53

54

  /* Init for SPI Interface */

55

  PORTS |= 0x80;

56

  DDRS = DDRS | 0xF0; /* outputs */

57

  SP0CR1 = 0x58; /* 0b01011000 */

58

  SP0CR2 = 0; /* Normal mode */

59

  SP0BR = 0x02; /* 1,0 MHz SPI clock */

60

61

  /* Init to the DAC */

62

  PORTS &= ~0x80;  /* /SS output low */

63

  mySPITrans(0x20); /* Init DAC Control Register Byte1 MSB first      */

64

  mySPITrans(0x00); /* Init DAC Control Register Byte2 24 bit total  */

65

  mySPITrans(0x02); /* Init DAC Control Register Byte3 LSB last       */

66

  PORTS |= 0x80;    /* /SS output high */

67

68

  while (i>0) /* Endles Data sending for testing only */

69

  { 

70

    VValueTo18BitDAC(myVValue);

71

    myVValue += DACStepWidth;

72

    if (myVValue > 5000000)

73

      myVValue = 0;

74

  }

75

76

  return 0;    

77

}

Hallo APW,

habe aus "Langeweile" trotzdem mal nen Versuch der Optimierung 
gestartet.
Habe mit Schrecken gelernt das double ja 8 byte lang ist.
Schau mal was Du von meiner Optimierungsidee denkst bitte.

Interrupts möchte ich wenn es eben geht vermeiden, weil damit 
überfordern wir Jochen fürchte ich. Dazu kommt das er ja offensichtlich 
nix ordentliches zum debuggen hat.

Grüße
Frank

Ich habe nun ein neues Problem:

Ich möchte auf jeden Wert des Sägezahns einen Sinus geben, bei dem ich 
Ampl + Frequenz und Anzahl der Perioden einstellen kann.

Das wird das neue Problem ;)

Ich bin für jede Hilfe dankbar :)

Danke!

Hallo Jochen.

schick mal mein Programm durch den geschwindigkeits test ;)
Das will ich jetzt wissen :D

Wie meinst DU auf jeden wert des Sägezahn?
Ich vermute Du willst auf den Sägezahn einen Sinus modulieren?

Grüße
Frank

Genau... und auf jeder Stufe soll dann einer sein ;)

Frank Sander schrieb:

> schick mal mein Programm durch den geschwindigkeits test ;)
> Das will ich jetzt wissen :D

Läuft schon ;)

Hat nicht den gewünschten Erfolg ;) Und noch so ein hässlicher Peak nach 
unten :(

Hattest Du den Takt auf 4 MHz geändert?
Wenn nicht bitte machen ;-)

Der PEak muss ich mal suchen warum ich da nen Überlauf rein bekomme ;-)

4 MHz liegen an:

1

 SP0BR = 0x00; /* 4,0 MHz SPI clock */

;)

Zum Thema Sinus habe ich mir überlegt, dass man ja die Amplitude, die 
der Sinus haben soll, einfach so umsetzen könnte, dass man zu dem DC 
Wert die Werte die man vorher errechnet hat hinzu addiert. Bloß wie man 
jetzt die Frequenz umsetzt? Die Sache mit einer oder 2 Perioden könnte 
man ja mit einer while-Schleife lösen oder?

Danke.

ok dann haben wir gelernt:

Es waren nicht unbedingt die Fließkommazahlen ;)
(hat der HC12 ne eingebaute FPU??)

das ist schön das hilft und wir können mit dem alten Programm weiter 
arbeiten.

Jochen dir muss klar sein: schneller wird es durch den Sinus nicht ;-)

Also Sinus aufmodulieren:

Was ist die maximale amplitude?
Was ist die maximal frequenz?

Grüße
Frank

Hallo Jochen,

das mit den 2 while Schleifen ist so eine Sache:
Du hast ja schon gelernt, das wir das Zeitverhalten des uC nicht 100% 
vorhersagen können. Wenn Du jetzt die Frequenz des Sinus über eine 
verschachtelte Schleife (im schlimmsten fall mit Wait) erzeugst, dann 
gibt das alles nur keinen Sinus mehr.

Um die position im Sinus (und damit den zugehörigen Wert) zu bestimmen 
brauchen wir dann doch einen Timer. Alles andere ist halbherzig.

Grüße Frank

Frequenz max: 100 kHz
Ampl max: 19 mA... in Volt... ?? Sagen wir 0,5 V!

Ja das ist schon klar, dass es langsamer wird... es dürfte dann bis zu 
0,5s brauchen ein Sinus... bzw 2 Perioden also 2 Sinuse ;)

Danke

Okay... owe ich sehe die Interrupts kommen ohoh! :)

Jochen das passt jetzt net zusammen:

100kHz und 0,5s 2 perioden

;)

Die 0,5 s war nur ein Wert den der Guru bei uns in den Raum gestellt 
hat... sie wollen wissen wie lange es dauert so was zu modulieren ;)

Hallo Jochen,

so kommen wir nicht weiter.
Kannst Du mir mal ein Bild skizzieren wie das Signal was ihr am ende 
braucht aussehen soll?

Ich muss verstehen was ich Dir erklären soll ;-)

Grüße
Frank

Wollen wir es nicht trotzdem für den Anfang mit einer while-Schleife 
probieren? Oder könnt ihr das mit dem Timer schnell umsetzen, bzw mir 
dabei helfen? Weil es soll schon nächste Woche laufen :(

Hier mal eine Skizze wie der Sinus an sich aussieht... und dieser kommt 
dann auf den Sägezahn bei jeder Stufe die wir haben... dadurch wird der 
Sägezahn sehr langsam...

Sorry für die schlechte Paint-Skizze ;)

Alles soweit verständlich?

Habe hier noch was zum Thema gefunden:

http://www.mikrocontroller.net/articles/Digitaler_Funktionsgenerator

Irgendwie macht mir die Sache gerade Bauchweh... :(

Hallo Jochen,

ok war jetzt nicht ganz was ich erwartet habe aber macht nix.
Ich hab mir hier parallel auch mal ein wenig nen Kopf gemacht:

Ich würde gerne 360 Punkte pro Zyklus setzen (darfst raten warum)
Dann täte ich gerne erst mal nur den Sinus bauen. Das aufmodulieren 
machen wir dann im 2. Schritt ;-)

Das Problem das ich jetzt habe:
Ich habe keinen blassen Schimmer über die Timer im HC12.
Da musst Du mal die passenden Passagen im Handbuch suchen und wenn es 
geht ein oder 2 Beispiele.

Dann hoffe ich das es eine sin Funktion in deinen Bibliotheken gibt!?
Kannst Du das bitte rausfinden? Wenn es die nicht gibt, dann werden wir 
uns ein Tabelle mit den entsprechenden Werten basteln müssen.

Alles klar?
Dann los ans Werk ;-)

Grüße
Frank

Floating-Point Math Functions

ICCV7 for CPU12 generates reentrant code including floating-point 
mathematics (at V6, ICC12 floating-point code is non-reentrant due to 
the use of static variables).

The following floating-point math routines are supported. You must 
#include <math.h> before using these functions.

    float asinf(float x)

returns the arcsine of x for x in radians.

    float acosf(float x)

returns the arccosine of x for x in radians.

    float atanf(float x)

returns the arctangent of x for x in radians.

    float atan2f(float y, float x)

returns the angle whose tangent is y/x, in the range [-pi, +pi] radians.

    float ceilf(float x)

returns the smallest integer not less than x.

    float cosf(float x) )

returns the cosine of x for x in radians.

    float coshf(float x)

returns the hyperbolic cosine of x for x in radians.

    float expf(float x)

returns e to the x power.

    float exp10f(float x)

returns 10 to the x power.

    float fabsf(float x)

returns the absolute value of x.

    float floorf(float x)

returns the largest integer not greater than x.

    float fmodf(float x, float y)

returns the remainder of x/y.

    float frexpf(float x, int *pexp)

returns a fraction f and stores a base-2 integer into *pexp that 
represents the value of the input x. The return value is in the interval 
of [1/2, 1) and x equals f * 2**(*pexp).

    float froundf(float x)

rounds x to the nearest integer.

    float ldexpf(float x, int exp)

returns x * 2**exp.

    float logf(float x)

returns the natural logarithm of x.

    float log10f(float x)

returns the base-10 logarithm of x.

    float modff(float x, float *pint)

returns a fraction f and stores an integer into *pint that represents x. 
f + (*pint) equal x. abs(f) is in the interval [0, 1) and both f and 
*pint have the same sign as x.

    float powf(float x, float y) )

returns x raised to the power y.

    float sqrtf(float x) )

returns the square root of x.

    float sinf(float x)

returns the sine of x for x in radians.

    float sinhf(float x)

returns the hyperbolic sine of x for x in radians.

    float tanf(float x) )

returns the tangent of x for x in radians.

    float tanhf(float x)

returns the hyperbolic tangent of x for x in radians.

Since, by default, float and double have the same size (32 bits), math.h 
also contains a set of macros that map the function names to be without 
the f suffix form. For example, pow is the same as powf, sin is the same 
as sinf, etc.




Daraus haben wir hier die Fkt:

    float sinf(float x)

returns the sine of x for x in radians.

Schonmal einwas ;)

bin schon am basteln ;-)

Der Timer heißt beim HC12 Enhanced Capture Timer... soweit ich weiß... 
nur ich habe auch damit so gut wie noch nie gearbeitet...

Außer dieses Blink-Programm:

1

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

2

#include <stdio.h>

3

#include "mc912d128.h"

4

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

5

void _HC12Setup(void) {

6

  COPCTL = 0x08;        // disable Watchdog

7

  }

8

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

9

#pragma interrupt_handler isrOC2

10

void isrOC2(void) {

11

TFLG1 = 0x04; // clear OC2 Intr Flag

12

TC2 += 31250u; // 1 interrupt every 31250 timer ticks (0.5s)

13

PORTH ^= 0x80; // toggle LED

14

}

15

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

16

void main(void) {

17

// install OC2 pseudo vector in RAM

18

// (if running with TwinPEEKs monitor)

19

*((unsigned char *)0x3FE2) = 0x06; // JMP opcode

20

*((void (**)(void))0x3FE3) = isrOC2;

21

// make PTH[7] an Output to drive the LED

22

DDRH |= 0x80;

23

// Timer Setup

24

TSCR = 0x80; // Timer enable

25

TMSK2 = 0x07; // Prescaler = 128 (1 timer tick every 16ìs)

26

TCTL2 = 0x00; // TC2 disconnected from Pin

27

TIOS |= 0x04; // TC2 is Output Compare

28

TMSK1 |= 0x04; // TC2 Interrupt enable

29

// enable Interrupts

30

asm("cli");

31

// loop endless (and let the interrupt work)

32

while(1) ;

33

}

34

//==============================================================

Wobei das uns jetzt glaube ich schon weiter bringt ;)

Sag mal wie weit dir das hilft!? Danke