Letzter Hilferuf AT91SAM7S - PWM oder PCK

Hi

hast du es schon mit dem PCK(x) probiert, diese Pins wo man den Clock 
raus führen kann?

wie genau brauchst du die 1MHz ???
wenn 1,152 MHz auch noch geht versuch es doch mal.

Für jeden Ausgang gib's ein PMC_PCK(x) Register, dort die Clock Source 
auswählen.
zB.: Main Clock -> 18,432 MHz
Dann einen Vorteiler -> 16 wählen.

Das Reg. PMC_SCER sollte 0x00000001 oder mit USB 0x00000081,
die PCK(0..2) sind die Bits 8..10 .
Ein Bit auf eins setzen, dann ist der Ausgang aktiviert.

Dies sollte eine Frequenz von 1,152 MHz ergeben und auch am 
entsprechenden Ausgang anliegen.

Stephan

Hallo Stephan,

Das hört sich schon mal ganz gut an. Allerdings bin ich mir nicht ganz 
sicher. Das wären ja rund 10% mehr. Nachdem diese Frequenz dann auch als 
Grundlage für die Ausgabe dient, denke ich nicht, dass das sehr gut ist. 
Es werden ja alle möglichen Dinge aufgrund dieser Frequenz berechnet. Um 
dann wieder alles geradezuziehen, müsste ich die 6510 Emu auch 10% 
schneller laufen lassen. Ich denke, dass das leider keine gute Lösung 
ist. Bedeutet das im Umkehrschluss, dass es über PCK nicht genauer geht?

MfG
Peter

Hi,

ok, wie sieht es bei dir mit der PLL Frequenz aus???
Diese kann ja ebenfalls als Source dienen.

Eine von beiden möglichen Quellen sollte ein vielfaches von den 1 MHz 
sein.
wenn du einen Quarz von 16 MHz verwenden kannst hast du deine 1 MHz im 
Handumdrehen

Stephan

noch die Teiler vergessen: 1 bis 64

Stephan

Ich bin kein SAM7-Profi, aber wieso verwendest du nicht einen Timer 
Counter im Waveform mode?

Gruesse

Marvin

naja, ich denke ich verwende die Möglichkeiten nicht, weil ich es 
einfach nicht begreife...

Schau dir mal in "AT91SAM7S Series Preliminary" das Kapitel 33.5.11.2 
an. Da ist das recht schoen beschrieben, wie es imho gehen sollte.

Alternativ hat natuerlich Stefan W. auch recht - ich hatte nur schon von 
vornerein gedacht, du haettest keinen passenden vielfachen Takt. Mit 
welcher Frequenz betreibst du den uC?

Gruesse

Marvin

Morgen,
also ich glaub das bekommen wir hin!

Wie sind denn deine Clocks ???
Hast du einen Timer frei ???

Stephan

Hi,
bei dieser Geschichte brauchst du keinen Interrupt das macht der Timer 
alles alleine!
also fangen wir an einen Timer einzustellen.
Was haben wir:

- Main-Clock -> 18,432 MHz
- 3 Timer zur Verfügung -> wir nehmen T0 Pin TIO_A
- 5 Interne Taktquellen:
1 T = 1 Takt -> Counter inc um 1
max 65535 Takte möglich

1

TIMER_CLOCK1   MCK/2   9,216 MHz  -> 1 T = 108,5 ns  -> 0xFFFF T =   7,1 ms

2

TIMER_CLOCK2   MCK/8   2,304 MHz  -> 1 T = 434,0 ns  -> 0xFFFF T =  28,4 ms

3

TIMER_CLOCK3   MCK/32    576 KHz  -> 1 T =   1,7 us  -> 0xFFFF T = 113,8 ms

4

TIMER_CLOCK4   MCK/128   144 KHz  -> 1 T =   6,9 us  -> 0xFFFF T = 455,1 ms

5

TIMER_CLOCK5   MCK/1024   18 KHz  -> 1 T =  55,5 us  -> 0xFFFF T =   3,6 s

soll Frequenz ist 1 MHz: 1/F = 1 us
Demnach können wir TIMER_CLOCK1 oder TIMER_CLOCK2 als Quelltakt wählen.
wir nehmen TIMER_CLOCK1, da bessere Auflösung!

 1 us / 108,5 ns = 9,2

 9  * 108,5 ns = 976,5 ns -> 1,024 MHz
 10 * 108,5 ns = 1,085 us -> 0,921 MHz

Wir müssen den Timer also bis 9 Zählen lassen.

- Waveform: siehe Punkt 33.5.11.2 im DB
 WAVSEL = 10 -> zählt von Null bis RC (unsere 9)
 Hier können wir den Counter bis zu unseren Wert 9 laufen lassen.
 Der Counter setzt sich selbst wieder zurück und fängt von vorne an.

Da bis jetzt noch nichts geschaltet wird, müssen wir noch die Schwelle 
aktivieren.
Dazu wird das RA Reg verwendet, um nun die Frequenz abzubilden müssten 
wir 9 / 2 verwenden,
da dies aber nicht geht, würde ich 5 oder 4 vorschlagen. (RA = 4) ;-)
Daraus ergibt sich also das entweder das Low- oder das High-Signal etwas 
größer ist!!!! (um 108,5 ns)

Jetzt solltest du noch die Polarität bestimmen, wann ist der Pin Low und 
High.
Dazu gibs die Reg.: (siehe Punkt 33.5.11.2 im DB)
- ACPA, RA Compare Effect on TIOA -> zB: SET Pin
- ACPC, RC Compare Effect on TIOA -> zB: CLEAR Pin

Ich hoffe ich hab nichts vergessen.

Stephan

Das ist grandios. Werde das in einer ruhigen Minute ausprobieren.

Vielen Dank!

...eine Frage noch:

Es gibt ja - so glaube ich - ein Statusregister zu den Pins. Kann ich 
das verwenden, um zu sehen, ob der Pin gerade High oder Low ist.

Weil ich sollte ja im Idealfall einen Zustandswechsel abwarten und "von 
dort aus" meine Daten übertragen. Dann bis zum nächsten Wechsel warten 
und fertig...

Hi,
Status Regs. gibt es.
Ist dein Programm wirklich so schnell???
Im schlimmsten Fall, liest du Pin ist High und das wiederholt sich und 
du kommst nicht aus der Schleife. (da das Auslesen immer zum gesetzten 
Level passiert)

ich würde es so machen:
lese TC Status Register, schmeiße das Ergebnis weg.
dann so lange lesen bis RA Compare Status oder RC Compare Status wieder 
gesetzt ist.
Wobei ich zum RC tendieren würde.
RA wäre dein Flankenwechsel und RC eine Periode.

Stephan

Peter Pippinger schrieb:
> ich habe ein Problem:
> Irgendwie habe ich mich in mein Projekt "SID-Player mit einem echten
> SID" sehr verbissen. Ich möchte das gerne zu Ende bringen.

Sehr lobenswert. Ich fange viel zu viel Hobbyprojekte an, die ich dann 
nicht zuende bringe.

> genauere Problembeschreibung:
> a) ich habe von Elektronik nicht viel Ahnung.
> b) ich finde keine für mich verständlichen Beispiele, wie ich mit meinem
> AT91SAM7S ein 1MHz Signal für den SID erzeugen kann. Bislang denke ich,
> dass man das entweder über PWM machen kann oder über PCK. Die Anleitung
> habe ich mir zu diesem Thema angesehen und nicht verstanden.
> b) ich möchte nur ungerne zusätzlich einen 1MHz Oszillator "verbraten",
> wenn doch der AT91SAM7S in der Lage ist, so ein Signal zu erzeugen.

Wenn es dein Hauptziel ist, den SID zum laufen zu bringen, wäre die 
einfachste Lösung erstmal tatsächlich noch einen externen 1 MHz 
Quartzoszillator zu verwenden. Sowas hat man normalerweise in der 
Bastelkiste rumliegen :-)

> Momentan ist das einzige, was mir noch fehlt die beiden
> Bypass-Kondensatoren für VCC und VDD

Das könnte schon wichtig sein. Falls du mehr mit Elektronik machen 
willst, würde ich dir empfehlen, ein paar Bauteile auf Vorrat zu kaufen, 
also z.B. ein Widerstandsortiment und ein paar oft verwendete 
Keramikkondensatoren und ggf. Elkos. Braucht man immer wieder.

> Also Ihr seht schon: viel ist es nicht mehr. Ich würde den Takt so gerne
> über PWM oder PCK erzeugen, aber ich check das einfach nicht. Zudem habe
> ich leider kein Oszilloskop, womit ich irgendwas messen könnte.

Ohne Oszilloskop wirst du nicht viel Spaß mit 
Microcontrollerentwicklungen haben, zumindest nicht wenn es was 
komplizierter wird mit schnellen Signalen, z.B. wenn du später mal die 
Steuerleitungen zum SID messen willst oder irgendwann mal I2C oder SPI 
debuggen willst. Ich habe z.B. das hier und bin da sehr zufrieden mit:

http://www.reichelt.de/?ARTICLE=84986

Die Software dazu ist kostenlos und seit der neuesten Version 
funktioniert sogar die Triggerfunktion vernünftig, sodaß ich mein 
Tektronix kaum noch verwende.

Frank Buss schrieb:
>> Momentan ist das einzige, was mir noch fehlt die beiden
>> Bypass-Kondensatoren für VCC und VDD
>
> Das könnte schon wichtig sein. Falls du mehr mit Elektronik machen

"Schon wichtig"

im Sinne von: da kann was kaputt gehen?
oder eher
im Sinne von: da kommen evtl. fehlerhafte Signale beim SID an?

...werde jetzt mal das mit der Taktung probieren...

Hallo

So, jetzt habe ich das mit dem Takt mal erfolglos probiert.
Mein Ziel wäre erst mal, den Timer zu starten. Dann möchte ich gerne 
zwischen meinen LED-blinkern eine Schleife haben, die so lange wartet, 
bis der Takt neu beginnt. Testen würde ich dann das Ganze, indem ich 
TC_RC so weit hochdrehe, dass die LED langsamer blinkt...

Der Code sieht momentan so aus:

1

AT91PS_TCB pTCB = AT91C_BASE_TCB;

2

AT91PS_TC pTC = AT91C_BASE_TC0;

3

4

void TimerSetup(void) 

5

{

6

  pTCB->TCB_BCR = 0;    // SYNC trigger not used

7

  pTCB->TCB_BMR = 0x15;   // external clocks not used

8

9

  pTC->TC_CCR = 0x5;      // enable the clock and start it

10

  pTC->TC_CMR = 0x4004;   // TCCLKS = 1 (TIMER_CLOCK5)

11

  pTC->TC_RC = 2346;      // 2346;

12

}

13

14

void main(void) 

15

{ 

16

  // init frequency

17

  InitFrec();

18

19

  // init leds / usart0

20

  InitPeriphery();

21

22

  TimerSetup();

23

24

25

  p_pPio->PIO_CODR = BIT17;  // LED 1 on

26

27

  // loop forever

28

  while(1)

29

  {

30

    p_pPio->PIO_CODR = BIT18;  // LED 2 on

31

    p_pPio->PIO_SODR = BIT17;  // LED 1 off

32

    wait(800000);

33

34

    p_pPio->PIO_SODR = BIT18;  // LED 2 off

35

    p_pPio->PIO_CODR = BIT17;  // LED 1 on

36

    wait(800000);

37

38

  // Hier sollte er eigentlich warten, bis der Takt wieder neu beginnt

39

  while(pTC->TC_SR != 0)

40

  {

41

  }

42

43

    p_pPio->PIO_CODR = BIT18;  // LED 2 on

44

    p_pPio->PIO_SODR = BIT17;  // LED 1 off

45

    wait(800000);

46

47

    p_pPio->PIO_SODR = BIT18;  // LED 2 off

48

    p_pPio->PIO_CODR = BIT17;  // LED 1 on

49

    wait(800000);

50

  }

51

52

  return (0);

53

}

Ok, dann muss ich wohl nachher zum Elektronikteilehändler meines 
Vertrauens und einen Oszillator usw. kaufen...

gute nacht

Hi

also ich glaub dein TC_CMR Register ist falsch beschrieben.
du brauchst die Beschreibung mit Wave= 1 denke ich.

1

TC_CMR= AT91C_TC_WAVE |     // Wave aktive

2

 AT91C_TC_WAVESEL_UP_AUTO |   // <- bin ich mir nicht sicher

3

 AT91C_TC_CLKS_TIMER_DIV5_CLOCK |   // Takt

4

 AT91C_TC_ACPA_SET |   // bei wert A setzen

5

 AT91C_TC_ACPC_CLEAR;  // bei wert C löschen

6

7

TC_RA= 1173;  // 50 % von RC

8

TC_RC= 2346;  // <- das war deins

erst alle! Parameter setzen und danach den Counter starten!!!
Sonst gibs komische Effekte.

Atmel geht sogar noch weiter bei der Init
und beim Starten der TC: (aus der Vers. 1.5)

1

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

2

/// Configures a Timer Counter to operate in the given mode. Timer is stopped

3

/// after configuration and must be restarted with TC_Start(). All the

4

/// interrupts of the timer are also disabled.

5

/// \param pTc  Pointer to an AT91S_TC instance.

6

/// \param mode  Operating mode (TC_CMR value).

7

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

8

void TC_Configure(AT91S_TC *pTc, unsigned int mode)

9

{

10

    // Disable TC clock

11

    pTc->TC_CCR = AT91C_TC_CLKDIS;

12

    // Disable interrupts

13

    pTc->TC_IDR = 0xFFFFFFFF;

14

    // Clear status register  <--------------------- hier ein Dummy Read!!!

15

    pTc->TC_SR;

16

    // Set mode

17

    pTc->TC_CMR = mode;

18

}

19

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

20

/// Enables the timer clock and performs a software reset to start the counting.

21

/// \param pTc  Pointer to an AT91S_TC instance.

22

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

23

void TC_Start(AT91S_TC *pTc)

24

{

25

    pTc->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;

26

}

27

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

28

/// Disables the timer clock, stopping the counting.

29

/// \param pTc  Pointer to an AT91S_TC instance.

30

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

31

void TC_Stop(AT91S_TC *pTc)

32

{

33

    pTc->TC_CCR = AT91C_TC_CLKDIS;

34

}

versuch mal das und gib Bescheid.

>// Hier sollte er eigentlich warten, bis der Takt wieder neu beginnt
dies würde ich anders schreiben:

1

// Hier sollte er eigentlich warten, bis der Takt wieder neu beginnt

2

  unsigned int tempTC_SR= pTC->TC_SR; // hier erst mal ein dummy read

3

  while(pTC->TC_SR != 0);   // und dann warten

bei deiner Lösung läuft er durch ist ja klar, da beim ersten mal was 
gesetzt war und wenn er wieder an diese Stelle kommt ist bestimmt irgend 
was gesetzt. also erst ein Dummy Read ausführen.

Stephan

Also ich hab das jetzt - so denke ich mal - korrekt eingebaut. 
Allerdings ergibt die Warteschleife zwischen den Blinkern einen 
Endlosloop...

Kann es sein, dass man erst mal wieder den Timerbereich im init-skript 
aktivieren muss? Wenn ja, wie sieht das ungefär aus?

Jetzt werd ich mich dann gleich mal um die Oszillator-alternative 
kümmern...

1

AT91PS_TCB pTCB = AT91C_BASE_TCB;

2

AT91PS_TC pTC = AT91C_BASE_TC0;

3

4

5

static void InitTimerCounter(void)   

6

{   

7

    pTC->TC_CCR = AT91C_TC_CLKDIS;

8

    // Disable interrupts

9

    pTC->TC_IDR = 0xFFFFFFFF;

10

    // Clear status register  <--------------------- hier ein Dummy Read!!!

11

    pTC->TC_SR;

12

    // Set mode

13

    pTC->TC_CMR = AT91C_TC_WAVE |     // Wave aktive

14

    AT91C_TC_WAVESEL_UP_AUTO |      // <- bin ich mir nicht sicher

15

    AT91C_TC_CLKS_TIMER_DIV5_CLOCK |   // Takt

16

    AT91C_TC_ACPA_SET |           // bei wert A setzen

17

    AT91C_TC_ACPC_CLEAR; 

18

19

20

  pTC->TC_RA = 1173;  // 50 % von RC

21

  pTC->TC_RC  = 2346;   

22

    pTC->TC_CCR = 5; //enable timer-counter and trig it          

23

24

    pTC->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;

25

}

26

27

28

void main(void) 

29

{ 

30

  // init frequency

31

  InitFrec();

32

33

  // init leds / usart0

34

  InitPeriphery();

35

36

  InitTimerCounter();

37

38

    p_pPio->PIO_CODR = BIT17;  // LED 1 on

39

40

  // loop forever

41

  while(1)

42

  {

43

    p_pPio->PIO_CODR = BIT18;  // LED 2 on

44

    p_pPio->PIO_SODR = BIT17;  // LED 1 off

45

    wait(800000);

46

47

    p_pPio->PIO_SODR = BIT18;  // LED 2 off

48

    p_pPio->PIO_CODR = BIT17;  // LED 1 on

49

    wait(800000);

50

51

  // int status=AT91C_BASE_TC0->TC_SR;

52

  unsigned int tempTC_SR= pTC->TC_SR; // hier erst mal ein dummy read

53

    while(pTC->TC_SR == 0)

54

    {

55

    };   // und dann warten

56

57

58

59

    p_pPio->PIO_CODR = BIT18;  // LED 2 on

60

    p_pPio->PIO_SODR = BIT17;  // LED 1 off

61

    wait(800000);

62

63

    p_pPio->PIO_SODR = BIT18;  // LED 2 off

64

    p_pPio->PIO_CODR = BIT17;  // LED 1 on

65

    wait(800000);

66

  }

67

68

  return (0);

69

}

Morgen,

ich hab hier was gefunden:

http://www.at91.com/forum/viewtopic.php/f,12/t,4203/

schau mal da, da sollte es laufen. ;-)
Hast du folgendes drin?

1

AT91C_BASE_PMC->PMC_PCER = (1<<AT91C_ID_TC0);      //enable clock

2

3

AT91C_BASE_PIOA->PIO_PDR = P_TIOA0;   //disable PIOA

4

AT91C_BASE_PIOA->PIO_BSR = P_TIOA0;   //select peripheral B

5

6

bzw:

7

// In order to select TIOA0, disable PB0 and select periph.A

8

AT91F_PIO_CfgPeriph (AT91C_BASE_PIOA, 0 , AT91C_PB0_TIOA0);

ich glaub das wars.

Stephan

Vielen Dank, werde ich später gleich mal testen. Hab den 1MHz Oszillator 
nicht bekommen. Der hatte erst ab 6MHz...

Hoffentlich funktioniert das mit dem Timer...

Bis später...

Peter Pippinger schrieb:
> "Schon wichtig"
>
> im Sinne von: da kann was kaputt gehen?
> oder eher
> im Sinne von: da kommen evtl. fehlerhafte Signale beim SID an?

Kaputtgehen kann eigentlich nichts, aber wenn die kurzzeitigen hohen 
Schaltströme, die bei CMOS-Bausteinen auftreten, nicht per 
Keramikkondensator abgefangen werden, dann kann die Spannung kurz 
einbrechen oder in extremen Fällen auch anfangen zu schwingen, je nach 
Verdrahtung, sodaß der SID unstabil arbeiten könnte, was auch das 
generierte Audiosignals beeinflussen könnte. Den Kondensator am besten 
direkt an den Versorgungspsannungs-Pins vom SID anlöten.

Da du übrigens keine Möglichkeit hast zu prüfen, ob die 1 MHz wirklich 
generiert werden, würde ich vorschlagen, einen Vorteiler zu wählen, 
sodaß es in den Audiobereich fällt, also bei ein paar kHz, falls 
möglich. Dann kannst du einfach einen hochohmigen Kopfhörer dranhängen 
(ein kleiner Piezo-Lautsprecher ist auch sehr gut geeignet) und hören, 
ob was rauskommt. Oder noch besser: per Soundkarte aufzeichnen. Gibt da 
gute Softwarelösungen für ein Soundkarten-Oszilloskop. Da kannst du dann 
die Frequenz exakt messen, wenn die niedriger als die Samplerate der 
Soundkarte ist. Dann die Frequenz raufsetzen.

Wenn alles nicht klappt: Ich habe hier auch noch einen 1 MHz 
Quarzoszillator mit 5 V Versorgungsspannung, den ich dir per 
Briefumschlag schicken könnte, sodaß du dir Versandkosten bei Reichelt 
o.ä. sparen würdest. Brauche ich sowieso nicht mehr, da die 
Microcontroller heutzutage ja meist per Quarz und nicht Quarzoszillator 
betrieben werden können und wenn man mal einen Quarzoszillator braucht 
(z.B. für FPGAs oder CPLDs), dann sowieso mit höherer Frequenz und 3,3 
V.

> Da du übrigens keine Möglichkeit hast zu prüfen, ob die 1 MHz wirklich
> generiert werden, würde ich vorschlagen, einen Vorteiler zu wählen,
> sodaß es in den Audiobereich fällt, also bei ein paar kHz, falls
> möglich. Dann kannst du einfach einen hochohmigen Kopfhörer dranhängen
> (ein kleiner Piezo-Lautsprecher ist auch sehr gut geeignet) und hören,
> ob was rauskommt.

ja, gute Ideen. Ich wollte irgendwas mit Schleifen & LED-Blinken machen 
um die Frequenz zu messen (naja, messen ist hier wohl optimistisch 
ausgedrückt :-)

> Wenn alles nicht klappt:

So ist es leider immer noch.
@Stephan W.: Hab Deine Beispiele in allen mir erdenklichen Versionen 
probiert, aber ich bekomm das nicht gebacken :-(

> Ich habe hier auch noch einen 1 MHz
> Quarzoszillator mit 5 V Versorgungsspannung, den ich dir per
> Briefumschlag schicken könnte, sodaß du dir Versandkosten bei Reichelt
> o.ä. sparen würdest. Brauche ich sowieso nicht mehr, da die
> Microcontroller heutzutage ja meist per Quarz und nicht Quarzoszillator
> betrieben werden können und wenn man mal einen Quarzoszillator braucht
> (z.B. für FPGAs oder CPLDs), dann sowieso mit höherer Frequenz und 3,3
> V.

Also das ist wirklich äußerst freundlich! Danke. Aber eine kleine Frage 
habe ich da noch. Muss der SID nicht am Clockinput nicht auch mit TTL 
betrieben werden?

siehe:
http://www.zimmers.net/anonftp/pub/cbm/schematics/computers/c128/manual/42.gif

Achso - dann passen 5V, oder:
http://www.elektronik-kompendium.de/sites/dig/0205171.htm

Also das mit dem Oszillator wäre wirklich ganz ganz nett, wenn Du mir 
den schicken könntest. Ich schick Dir meine Adresse via E-Mail. Vielen 
Dank schon mal.

3,3 V würden aber auch gehen, denn laut dem Datenblatt sind nur 
mindestens 2 V notwendig, auch für den Takteingang: 
http://sid.kubarth.com/files/ds_6581.pdf

Ich schicke dir aber vorsichtshalber gerne den Quarzoszillator. eMail 
habe ich noch keine bekommen, soll ich es an deine unter Xing 
eingetragene Adresse schicken?

Morgen

könntest du den Code noch einmal mit den aktuellen Stand posten?
Das muss doch zu lösen sein?
Das ist eine Frage der Ehre!!!!

Stephan

PS: Wenn du anstatt den Pin zu wackeln do mal einen RC Compare INT 
schreibst, und dort was machst? (LED Schalten alle x mal oder so...)
So wüssten wir das der Timer läuft.

Hi,
hab noch was gefunden, vielleicht hilft es.

Stephan

Wirklich sehr einfach für Hardwarekonfiguration usw. ist CodeWarrior mit 
dem "Processor Expert". Da kann man sich einfach per Eingabemasken 
eintragen und zusammenklicken, was man haben will. Die Eingebamasken 
nehmen einem alle Arbeit des Datenblatt-Lesens ab: Z.B. einfach 
eintragen, was für eine Frequenz man für einen periodischen Interrupt 
haben will und der Processor Expert sagt einem, mit welchem Fehler es 
machbar ist und generiert allen dazu nötigen Code:

http://www.frank-buss.de/MC9S08JS16L/

Ich bin allerdings eigentlich nicht ein Anhänger solcher Wizards, denn 
den Code kann man später meist nicht gut weiterentwickeln und wenn man 
die Register selber programmiert, dann hat man auch den Chip besser 
verstanden und kann besser die Fähigkeiten des Chips einschätzen und 
planen.

So habe ich z.B. mal die Register von einem Cypress PSoC Chip selber 
programmiert, statt den "Device Editor" zu nehmen, was interessant war, 
aber schon grenzwertig ist und wo ein grafischer Editor schon fast ein 
Muß ist, da es da sehr viele Bedingungen, Einschränkungen und 
Kombinationen zu beachten gibt:

http://www.frank-buss.de/rs232toi2c/

Ich weiß, ich habe merkwürdige Hobbies :-)

Der AT91SAM7 ist aber eher noch ein einfacher Chip in dieser Hinsicht. 
Nur leider sind die Atmel-Datenblätter manchmal ein wenig umständlich 
geschrieben, aber gibt auch da schlimmeres: Z.B. musste ich mal mit 
einem Datenblatt von einem Silicon Motion Chip arbeiten und obwohl der 
Chip recht gut war, war das Datenblatt sehr lückenhaft, da manchmal nur 
stand, wie ein Bit eines Registers hiess, aber nirgends zu finden war, 
was das Bit denn nun genau macht, sodaß man anhand des Namens und 
vielleicht ein wenig Beispielcode vom SDK erraten musste, wie es genau 
in eigenen Programmen zu verwenden ist (da der Support auch nicht sehr 
hilfreich war).

@frank: Der Oszillator ist leider noch nicht angekommen... vielleicht 
kommt er ja morgen :-)

@stephan: Hab heute mal ne Mail an den ATMEL Support geschrieben und 
nochmal unterstrichen wie wichtig mir die Sache ist. Prompt habe ich ne 
Antwort bekommen. Werde wahrscheinlich erst am WE dazukommen, das zu 
prüfen... Aber für die, die es interessiert:

Hello Peter,

You will find below a piece of code which initializes the PA21 I/O line 
to
output the main oscillator signal on PCK1:
AT91C_BASE_PIOA->PIO_PDR = 0x00200000; // Configure PA21 to be driven by
peripheral
AT91C_BASE_PIOA->PIO_OER = 0x00200000; // Configure PA21 as output
AT91C_BASE_PIOA->PIO_PPUDR = 0x00200000; // Disable pull-up on PA21
AT91C_BASE_PIOA->PIO_BSR = 0x00200000; // Assign PA21 to peripheral B
function

AT91C_BASE_PMC->PMC_SCER |= 0x00000200; // Enable PCK1
AT91C_BASE_PMC->PMC_PCKR[1] = 0x1; // Select Main Osc Output

Hope this help.

(anm. peter) ATMEL rocks!

also jetzt wirds ernst :-)

habe eben folgendes getestet. Ratet mal, was die gelbe LED gemacht 
hat...

..richtig: schwächer als sonst geleuchtet. Das bedeutet wohl, dass schon 
mal die Mainclock wie vom ATMEL-Support beschrieben ausgegeben wird :-)

Ist es eigentlich schlimm eine LED im MHz-Bereich zu schalten?

Ich bin so aufgeregt...


int main ( void )
{

  AT91C_BASE_PIOA->PIO_PDR = 1 << 17; // Configure PA17 to be driven by 
peripheral
  AT91C_BASE_PIOA->PIO_OER = 1 << 17; // Configure PA17 as output
  AT91C_BASE_PIOA->PIO_PPUDR = 1 << 17; // Disable pull-up on PA17
  AT91C_BASE_PIOA->PIO_BSR = 1 << 17; // Assign PA17 to peripheral B 
function

  AT91C_BASE_PMC->PMC_SCER |= 0x00000200; // Enable PCK1
  AT91C_BASE_PMC->PMC_PCKR[1] = 0x1; // Select Main Osc Output

  while(1){}
}

Ok, es ist in der Tat ein Signal. Habe nun auf der 2. LED den Status 
dargestellt (LED2 blinkt langsam -> hängt an PCK von LED1). Allerdings 
werde ich so wohl kaum "messen" können, wievie Hertz am PIN tatsächlich 
rauskommen, da der Code ja auch den ein oder anderen Takt benötigt... 
Hmm, hat jemand eine Idee, wie ich das machen könnte. Über einen 
Interrupt würde das bestimmt gehen, so dass ich x nur alle 10000 Takte 
auswerte und auf der LED ausgebe... Wollte eigentlich versuchen, dass 
die LED im Sekunden-Takt blinkt, und somit die Hertzzahl "messbar" ist. 
Kann vielleicht nochmal jemand die Zeilen um einen Teiler erweitern? 
Dann müsste man da auch gut "messen" können... Sozusagen die jetzige 
Config MIT einem Teiler (z.B. 64).
Danke schon jetzt dafür.
Peter

1

int main ( void )

2

{

3

  // init frequency

4

  // InitFrec();

5

6

  // init leds / usart0

7

  InitPeriphery();

8

9

  AT91C_BASE_PIOA->PIO_PDR = 1 << 17; // Configure PA17 to be driven by peripheral

10

  AT91C_BASE_PIOA->PIO_OER = 1 << 17; // Configure PA17 as output

11

  AT91C_BASE_PIOA->PIO_PPUDR = 1 << 17; // Disable pull-up on PA17

12

  AT91C_BASE_PIOA->PIO_BSR = 1 << 17; // Assign PA17 to peripheral B function

13

14

  AT91C_BASE_PMC->PMC_SCER |= 0x00000200; // Enable PCK1

15

  AT91C_BASE_PMC->PMC_PCKR[1] = 0x1; // Select Main Osc Output

16

17

  int x = 0;

18

  int blink = 0;

19

20

  while(1)

21

  {

22

    if(!((p_pPio->PIO_PDSR) & (1 << 17))) 

23

    {

24

      x++;

25

26

      if (x > 1800000)

27

      {

28

        x = 0;

29

        if (blink == 0)

30

        {

31

          p_pPio->PIO_CODR = BIT18;  // led2 on

32

          blink = 1;

33

        }

34

        else

35

        {

36

          p_pPio->PIO_SODR = BIT18;  // led2 off

37

          blink = 0;

38

        }

39

      }

40

    }

41

42

  }

43

}

Morgen,

na da haste ja schnell eine Antwort bekommen. :-)
Aber ich dachte die mögliche Frequenz war dir zu groß?

im Reg. PMC_PCKR machst du die Einstellungen, welcher Clock und mit 
welchem Teiler gearbeitet werden soll.

momentan ist kein Teiler und der Mainclock gewählt. (18,432MHz)
mit einem Teiler von 64 und dem Mainclock wäre der Wert:

AT91C_BASE_PMC->PMC_PCKR[1] = 6 << 2 | 1;

siehe DB Kapitel 26.9.11

Stephan

Hi,
ja du kannst den SLOW-Clock als Quelle wählen, müssten 32 KHz sein. 
(Teiler auf 32)
Wenn du dann bis 1000 zählst sollte es ungefähr 1 Sekunde ergeben.

Der Takt selber läuft ohne MC Unterstützung, im Grunde musst du dir das 
so vorstellen, das eine Leitung von deinem Quarz über einen Teilen nach 
außen geführt wird. (vereinfacht gesprochen, Schaltbild gibt es im 
Datenblatt)

Stephan

Hi,
steht auch im Register: PMC_PCKR !

Stephan

OK, danke. Aber eine Frage habe ich noch: Betrifft die Slow-Clock in 
diesem Fall dann nur diesen besagten Pin, oder wird dadurch auch der 
AT91SAM7S256-Takt langsamer? Weil wenn dem so wäre, dann würde mir das 
in diesem Fall auch nicht ein sicheres abfragen ALLER High-Low 
Statuswechsel garantieren...

Hallo Frank,

meine Frau hat mir eben Deinen Brief mit dem Oszillator und den 
Kondensatoren gegeben :-)

Vielen vielen Dank!

Ich denke, dass mit all dem Wissen und em Equipment nun nichts mehr im 
Wege stehen sollte, dem SID spätestens am WE ein paar Töne zu entlocken 
:-)

Danke.

Gruß,
Peter

Hi

der Slow-Clock ist immer da, der startet den MC so zusagen.
Diese Einstellung bezieht sich nur auf den Ausgangspin für diese 
Funktion.
Dein MC bleibt auf der alten Geschwindigkeit.

Du kannst ja auch allen 3 Ausgangspins eine unterschiedliche Frequenz 
geben.
1. Pin Slow-Clock
2. Pin Main-Clock
3. PLL Clock ( obwohl ich bezweifele das der MC die schnellen Frequenzen 
kann)

Stephan

So, jetzt glaube ich wirklich, dass ich langsam begreife, wie das Zeug 
hier funktioniert :-)

was ich gestern vergessen hatte (da bin ich tatsächlich selber drauf 
gekommen): Ich muss natürlich innerhalb des High auch so lange warten, 
bis wieder low anliegt, sonst stimmt ja der Zähler nicht. Was soll ich 
sagen? die LED switched nun 1/s. Cool.

1

  ...

2

  AT91C_BASE_PIOA->PIO_PDR = 1 << 17; // Configure PA17 to be driven by peripheral

3

  AT91C_BASE_PIOA->PIO_OER = 1 << 17; // Configure PA17 as output

4

  AT91C_BASE_PIOA->PIO_PPUDR = 1 << 17; // Disable pull-up on PA17

5

  AT91C_BASE_PIOA->PIO_BSR = 1 << 17; // Assign PA17 to peripheral B function

6

7

  AT91C_BASE_PMC->PMC_SCER |= 0x00000200; // Enable PCK1

8

  AT91C_BASE_PMC->PMC_PCKR[1] = 0x0 + 4 + 16 ; // Select Main Osc Output + Slow Clock

9

10

  int x = 0;

11

  int blink = 0;

12

13

  while(1)

14

  {

15

    if(!((p_pPio->PIO_PDSR) & (1 << 17))) 

16

    {

17

      x++;

18

      // wait until the next status change

19

      while(!((p_pPio->PIO_PDSR) & (1 << 17)))

20

      {

21

      }

22

23

      if (x > 1000)

24

      {

25

        x = 0;

26

        if (blink == 0)

27

        {

28

          p_pPio->PIO_CODR = BIT18;  // led2 on

29

          blink = 1;

30

        }

31

        else

32

        {

33

          p_pPio->PIO_SODR = BIT18;  // led2 off

34

          blink = 0;

35

        }

36

      }

37

    }

38

  }

Man sollte den Code dann noch ein wenig aufräumen. Hier ein paar Tipps:

- Code immer so schreiben, daß man keinen Kommentar braucht
- das beinhaltet z.B.: keine magischen Zahlen verwenden
- kurze Funktionen verwenden
- direkte Hardwarezugriffe von der Programmlogik trennen

Könnte dann so aussehen (ungetestet)

1

#define CLOCK_BIT (1 << 17)

2

#define LED_BIT (1 << 18)

3

4

void initClock(void)

5

{

6

  AT91C_BASE_PIOA->PIO_PDR = CLOCK_BIT; // Configure PA17 to be driven by peripheral

7

  AT91C_BASE_PIOA->PIO_OER = CLOCK_BIT; // Configure PA17 as output

8

  AT91C_BASE_PIOA->PIO_PPUDR = CLOCK_BIT; // Disable pull-up on PA17

9

  AT91C_BASE_PIOA->PIO_BSR = CLOCK_BIT; // Assign PA17 to peripheral B function

10

11

  AT91C_BASE_PMC->PMC_SCER |= 0x00000200; // Enable PCK1

12

  AT91C_BASE_PMC->PMC_PCKR[1] = 0x0 + 4 + 16 ; // Select Main Osc Output + Slow Clock

13

}

14

15

inline void setLed2(int on)

16

{

17

  if (on) {

18

    p_pPio->PIO_CODR = LED_BIT;

19

  } else {

20

    p_pPio->PIO_SODR = LED_BIT;

21

  }

22

}

23

24

inline int isClockBitSet(void)

25

{

26

  return (p_pPio->PIO_PDSR & CLOCK_BIT) == CLOCK_BIT;

27

}

28

29

inline void waitForFallingEdgeOnClockPin(void)

30

{

31

  while (!isClockBitSet()) {}

32

  while (isClockBitSet()) {}

33

}

34

35

void main(void)

36

{

37

  int x = 0;

38

  int blink = 0;

39

  initClock();

40

  while (1) {

41

    waitForFallingEdgeOnClockPin();

42

    if (x++ == 1000) {

43

      setLed2(blink);

44

      blink = !blink;

45

      x = 0;

46

    }

47

  }

48

}

Die "magischen" Zahlen 0x00000200 usw. kann man bestimmt auch noch mit 
den entsprecheneden defines aus den include-Dateien der Atmel-Libraries 
ersetzen, da wo auch AT91C_BASE_PIOA usw. herkommt.

Manchmal muß man aber Kompromisse machen, wenn z.B. der Takt-Pin sehr 
schnell schaltet und da kann dann auch sogar eine kurze Assemlber-Inline 
Routine notwendig werden. Sowas sieht man dann aber nur noch per 
Oszilloskop, denn auch wenn man die Assembler-Ausgabe des C-Compilers 
analysieren würde, würde man Effekte wie Prozessor-Cache usw. nicht so 
leicht manuell berücksichtigen können.

Ich denke aber immer noch, daß es für den SID egal ist, mit welcher 
Flanke sich die Signale exakt ändern, sodaß du nur entsprechend 
Chipselect usw. zu setzen brauchst und dann ein wenig warten, wie in dem 
anderen Thread zum SID beschrieben.

Hallo Frank,

vielen Dank für die Tips. Man möchte es vielleicht nicht glauben, aber 
ich verdiene meine Brötchen auch mit dem Programmieren :-) Bin 
eigentlich immer bemüht, die Dinge sio zu machen, wie Du sie oben 
beschrieben hast. Der Code ist (noch) mit der heißen Nadel und ganz 
wenig Zeit gestrickt, da ich einfach noch viel zu viel umbauen, testen 
und verstehen musste. Also die Chancen stehen gut, dass der Code am Ende 
besser aussieht :-)

> Ich denke aber immer noch, daß es für den SID egal ist, mit welcher
> Flanke sich die Signale exakt ändern, sodaß du nur entsprechend
> Chipselect usw. zu setzen brauchst und dann ein wenig warten, wie in dem
> anderen Thread zum SID beschrieben.

Im Prinzip gebe ich Dir da recht. Man müsste aber dann - so denke ich - 
mindestens 2 Takte warten, da der "Einstiegspunkt" ja nicht feststeht. 
Das wiederum könnte ja durchaus dazu führen, dass ein Register 2x 
hintereinander gesetzt wird. Ich weiß nicht, der Gedanke daran gefällt 
mir nicht so gut. Es tut ja nicht weh, diesen Wechsel abzuwarten...

Klar, du kannst versuchen, den Wechsel abzuwarten. Bei 1 MHz müsstest du 
dann aber berücksichtigen, wieviel Takte der Code braucht, um den Test 
durchzuführen und den Pin umzuschalten. Das kann schwierig werden, falls 
man Prozessor Cache, Pipelining und ggf. zusätzlich Latenz beim 
GPIO-Umschalten berücksichtigen muß, denn manche CPUs schalten die GPIOs 
nicht mit dem Prozessor-Takt um bzw. lesen den neuen Status ein, sondern 
mit einem langsameren IO-Takt (war glaube ich bei den AT91-Chips auch 
so). Wenn du also von der Programmlogik her meinst, einen Pegelwechsel 
am Pin erkannt zu haben, dann liegt der in Wirklichkeit vielleicht schon 
viele Prozessortakte in der Vergangenheit. Im schlimmsten Fall führt das 
dann dazu, daß du das Timing genau falsch machst (also z.B. 180° 
phasenverschoben) und den SID nicht angesprochen bekommst, obwohl du es 
nur gut meinst :-)

Wenn es langsamer ist, dann wird die Blinkfrequenz stimmen, also wenn du 
bis 1000 zählst, der Ausgang auch auf 1000 Hz ist und du eine 
Blinkfrequenz von 0,5 Hz messen kannst, dann stimmt das für diesen Fall. 
Wenn du dann anhand der Register meinst, daß du eine Frequenz an dem Pin 
von 1 MHz hast und dann bis 1 Millionen zählst und immer noch 0,5 Hz 
misst, dann funktioniert es. Kannst ja zum Spaß dann auch mal den Quarz 
an einem GPIO dranhängen (die IOs sind ja 5V tolerant) und messen, da 
sollte die LED dann auch mit 0,5 Hz blinken, falls es nicht zu sehr 
prellt, sonst die Glitch-Filter des AT91 einschalten.

Generell ist es aber schon so, daß du nicht sofort mitbekommst, wann ein 
Pegel extern wechselt. Für einen Feuerknopf am Joystick wird aber die 
Mikrosekunden Verzögerung nicht allzuviel ausmachen :-)

Ich weiß, Datenblatt lesen ist nicht dein Fall, aber in dem Datenblatt 
hier:

http://www.atmel.com/dyn/resources/prod_documents/doc6175.pdf

findest du auf Seite 245 das Output Line Timing. Da siehst du mehrere 
Takte Verzögerung beim Schreiben auf einen Port. "APB Access" bedeutet 
übrigens, daß das der Zeitpunkt ist, bei dem der APB-Bus frei ist, zum 
PIO Daten zu schaufeln. Auf Seite 4 findest du da eine Übersicht zu. APB 
heisst übrigens "Advanced Peripheral Bus" ausgeschrieben und ist Teil 
der AMBA Spezifikation, wie du hier nachlesen kannst:

http://en.wikipedia.org/wiki/AMBA_specification

Das ist aber schon recht tiefgehend. Für dich wichtig ist, daß an den 
APB-Bus viele Einheiten angebunden sind und wenn der Chip gerade damit 
beschäftigt ist, das Flash anzusprechen, z.B. um deinen Code zu laden, 
dann kann der nicht auf die GPIOs zugreifen und muß da erstmal warten.

Und schließlich kommt noch die Latenz durch die Pipeline hinzu. Laut dem 
Artikel hier:

http://de.wikipedia.org/wiki/ARM-Architektur

hat der ARM7-Core, der in dem AT91SAM7S eingesetzt wird, eine 
dreistufige Pipeline. Also alles in allem würde ich mal von dem Befehl 
zum Lesen des Pins rückwärts in der Zeit mit 5-8 Takten rechnen. Diesen 
Wert bekommst du dann. Wenn dann noch ein paar mehr Befehle dahinter zum 
Auswerten kommen, ist man schnell bei 10 Takten. Ginge vielleicht noch, 
aber du musst dasselbe ja auch wieder für den Ausgang rechnen. Daher 
meine Vermutung, daß du eine kräftige Phasenverschiebung reinbekommst, 
die man praktisch nur per Oszilloskop messen kann. Wäre aber möglich, 
daß 1 MHz noch machbar ist.

Ist alles nicht so einfach, wie bei kleinen 8-bittigen Microcontrollern.

Und schon wieder ein Datenblatt :-) siehe zum Anschluss am Audio Out 
Seite 8:

http://sid.kubarth.com/files/ds_6581.pdf

Die Ausgangsspannung hängt also davon ab, wieviel du an VDC reingibst. 
5V scheinen auch zu gehen, was die Beschaltung einfacher macht.

Als Last ist da 1 kOhm angegeben. Ich würde das besser auch nicht 
stärker belasten, also eher kein Walkman Kopfhöhrer (es sei denn mit 1 
kOhm Vorwiderstand, was dann recht leise klingen wird), sondern besser 
Soundkarten- oder HiFi-Anlageneingang.

Hallo Frank,

Wollte Dir noch sagen, dass das Beispiel von Dir, wie der Code aussehen 
könnte echt elegant ist. Gefällt mir.

Ich habe nun mal die Funktion geschrieben, um die Datenleitung und 
Adressleitung zu setzen. Was mir dabei gleich noch aufgefallen ist:

Bei meinem Board 
http://www.olimex.com/dev/pdf/ARM/ATMEL/SAM7-P256-SCH-REV-F.pdf sind 
manche I/O-Pins, die rausgeführt werden bereits belegt. Bringt das 
Probleme in der Zukunft? Gerade wenn ich mir z.B. den SDCard-Slot 
ansehe. SID würde beim Zugriff ruhen. Kann dem SID was passieren, wenn 
ich auf die SDCard zugreife? Und anders herum kann der SDCard was 
passieren, wenn ich auf den SID zugreife? Gerade auch vor dem 
Hintergrund 5V TTL (SID lesen).

Z.Zt würde ich die Leitungen so in der Art benützen
5 oder 6 Leitungen warens glaube ich für den HD44780 (4Bit)
RS232 wäre auch nicht schlecht, da ich da ganz gut "poorman debugger" 
spielen kann...

(PAxx rausgeführt / paxx nicht):

PA01 - SID A1
PA02 - SID A2
PA03 - SID A3
PA04 - SID A4
PA05 - SID Reset
PA06 - SID TAKT
PA07 - SID R/W
PA08 - SID CS
PA09 - SID D0
PA10 - SID D1
PA11 - SID D2  SD Card
PA12 - SID D3  SD Card
PA13 - SID D4  SD Card
PA14 - SID D5  SD Card
PA15 - SID D6
PA16 - SID D7
pa17 -    LED2
pa18 -     LED1
pa19 -     Button1
pa20 -    Button2
PA23 -
PA26 -
PA27 -
PA28 -
PA29 -
PA30 -
PA31 -

Hoffe, dass ich morgen abend/nacht schon mal das erste Lied 
rausbekomme...

Wie es aussieht hat das Olimex-Board die SD-Card direkt angeschlossen, 
ohne zusätzlichen Schutzchip. Das ist ok, wenn du die SD-Card immer nur 
dann wechselst, wenn der Strom aus ist.

Den SID würde die 3,3 V von der SD-Card nicht stören, falls das immer 
per Chipselect sauber getrennt ist. Hängt dann von der SD-Card ab, ob 
die die 5 V mag, wovon ich jetzt erstmal nicht ausgehen würde (also SID 
oder SD-Card fängt an zu rauchen :-) . Wenn du planst, da eine 
einzustecken, dann würde ich andere Pins emfpehlen. Die ARM-Architektur 
ist ja recht effizient, falls der Compiler gut ist, was das 
Auseinandernehmen von Wörtern und das Verschieben von Bits betrifft, 
sodaß die nicht kontinuierlich hintereinander liegen müssen. Vorteil 
wäre auch, daß man per PDC im Hintergrund, ohne Prozessorlast, auf den 
SPI-Bus für die SD-Card zugreifen kann und parallel dazu dann den SID 
ansteuern kann, falls du mal parallel zum Playback Lieder nachladen 
willst.

Hallo Frank,

das habe ich mir schon fast gedacht, dass ich da aufpassen muss... Das 
Auseinandernehmen der Bits würde dann mit schieben und logischen 
Operatoren machen, oder gibts da was ganz spezielles?

Momentan würde ich grob gesagt auf ein Bit Testen und das dann an die 
richtige Stelle "übersetzen"...

Mal noch was ganz anderes: Beim Setzen der High-Low Zustände auf den 
Pins:

es gibt doch 2 Möglichkeiten:
CODR + SODR:
    da lösche ich doch erst mal die Bits mit CODR, die ich nicht mag
    und mit SODR setze ich die, die ich mag. Aber das bedeutet doch,
    dass zwischen CODR und SODR ein falsches "Ausgangsbild" entsteht,
    oder? Kann man dem AT91SAM7S irgendwie sagen, dass er den neuen
    Zustand per Befehl übernehmen soll?

Dann gibts ja glaube ich auch die Möglichkeit High und Low über ein 
einziges Register zu beschreiben. Ich sag mal salopp: wo 0 und 1 als Low 
und High interpretiert wird. Das habe ich auch schon mal gemacht. Aber 
dazu müsste ich doch erstmal den "Gesamtzustand" holen, den dann 
anpassen und dann zurückschreiben (über dieses Register)?

Welchen Weg würdest Du als sauber und schnell einschätzen?

Gruß
Peter

Ich weiß, Datenblätter lesen sich nicht unbedingt wie ein spannender 
Roman :-) aber schau dir mal 27.4.5 hier an:

http://www.atmel.com/dyn/resources/prod_documents/doc6175.pdf

Hallo NG,

habe mir heute einen 16MHz Quarz gekauft und anstatt des 18,432MHz auf 
das Board gebaut. Leider sagt Windows dann schon, dass es die Hardware 
nicht kennt, oder kein passender Treiber installiert ist.

Kann ich den Quarz nicht einfach austauschen? Mit dem anderen 
funktionierts ohne Probleme...

MfG
Peter

Nein, den Quarz kannst du nicht einfach so tauschen, da die Frequenz für 
USB gebraucht wird, vermute ich mal. Genaueres sagt aber das Datenblatt 
und die Schaltung.

Ich denke nicht, daß es da ein Problem geben wird. Laut Datenblatt 
fliessen bei eingeschalteten Pullups maximal 600 uA nach Masse. Das 
einzige was dabei dann dem Atmel gefährlich werden könnte ist, wenn es 
sich summiert, sodaß VDDIO dann von der Spannung zu hoch wird, weil 
normale Spannungsregler meist nur Last ausregeln können, aber nicht 
Spannung wegregeln können, die an der Ausgangsseite angelegt wird. Ich 
denke mal, du könntest das Problem recht leicht umgehen, indem du die 
maximale Last, also bei 8 Anschlüssen vom SID Richtung Atmel 48 mA, als 
Last an VDDIO dranhängst, wenn du ganz sicher gehen willst.

Wenn du allerdings den SID Chipselect per Pullup angeschlossen hast, 
dann kommt nach dem Reset der SID gar nicht mit aktiven Ausgängen, sodaß 
du also vom Programm her alle Zeit der Welt hast, erstmal die Pullups 
auszuschalten, sodaß du das dann auch nicht mehr brauchst. Aber du 
kannst ja sicherheitshalber nochmal für deinen konkreten Fall beim Atmel 
Support anfragen, die helfen meist gut weiter. Und ein Multimeter an 
VDDIO dranhängen und sobald es zuviel Spannung zeigt, schnell den 
Stecker ziehen :-)

Hallo Frank,

bin mir zwar nicht sicher, ob ich im letzten Post ein wenig Sarkasmus 
gelesen habe, aber trotzdem Danke. Ich denke jetzt dauerts nicht mehr 
lang, bis der SID kaputt ist, oder alles funktioniert.

Habe eben die Adress und Datenleitungen gefüttert. Denkst Du, dass das 
hier ok ist, oder gibt es einen eleganteren Weg (wenn man Felxibilität 
mit der Pinbelegung haben möchte):

1

#define LED1      BIT17

2

#define LED2      BIT18

3

#define BUTTON1   BIT19

4

#define BUTTON2   BIT20

5

6

#define SID_A0    BIT0

7

#define SID_A1    BIT1

8

#define SID_A2    BIT2

9

#define SID_A3    BIT3

10

#define SID_A4    BIT4

11

#define SID_RES   BIT5

12

#define SID_CLOCK BIT6

13

#define SID_RW    BIT7

14

#define SID_CS    BIT8

15

16

#define SID_D0    BIT16

17

#define SID_D1    BIT23

18

#define SID_D2    BIT26

19

#define SID_D3    BIT27

20

#define SID_D4    BIT28

21

#define SID_D5    BIT29

22

#define SID_D6    BIT30

23

#define SID_D7    BIT31

24

25

p_pPio->PIO_ODSR = 

26

    (((adresse & 1)/1)    * SID_A0) +

27

    (((adresse & 2)/2)    * SID_A1) +

28

    (((adresse & 4)/4)    * SID_A2) +

29

    (((adresse & 8)/8)    * SID_A3) +

30

    (((adresse & 16)/16)  * SID_A4) +

31

32

    (((wert & 1)/1)       * SID_D0) +

33

    (((wert & 2)/2)       * SID_D1) +

34

    (((wert & 4)/4)       * SID_D2) +

35

    (((wert & 8)/8)       * SID_D3) +

36

    (((wert & 16)/16)     * SID_D4) +

37

    (((wert & 32)/32)     * SID_D5) +

38

    (((wert & 64)/64)     * SID_D6) +

39

    (((wert & 128)/128)   * SID_D7);

Gruß und gute Nacht,
Peter

Hallo,

jetzt habe ich mal alles angeschlossen und den "Code" für einen Ton an 
den SID geschickt. Das Einzige was passiert, ist dass er kurz knackst 
und das wars dann... Keine Ahnung, wie ich jetzt weiter vorgehen soll. 
Hab natürlich schon ein paar Sachen Probiert.

Die Leitungen habe ich im "Slowmotion"-Modus mit LED geprüft. Das hat 
eigentlich alles super ausgesehen von der Reihenfolge und so... Timings 
habe ich auch verschiedene probiert. Alles ohne Erfolg...

hier mal das Chaos bis jetzt:

1

#include "Board.h" 

2

#include "AT91SAM7S256.h"

3

4

#define LED1    BIT17

5

#define LED2    BIT18

6

#define BUTTON1    BIT19

7

#define BUTTON2    BIT20

8

9

#define SID_A0    BIT0

10

#define SID_A1    BIT1

11

#define SID_A2    BIT2

12

#define SID_A3    BIT3

13

#define SID_A4    BIT4

14

#define SID_RES    BIT5

15

#define SID_CLOCK  BIT6

16

#define SID_RW    BIT7

17

#define SID_CS    BIT8

18

19

#define SID_D0    BIT16

20

#define SID_D1    BIT23

21

#define SID_D2    BIT26

22

#define SID_D3    BIT27

23

#define SID_D4    BIT28

24

#define SID_D5    BIT29

25

#define SID_D6    BIT30

26

#define SID_D7    BIT31

27

28

#include "system.h"

29

#include "system.c"

30

31

// Pullups für die Datenleitungen und die Taktleitung deaktivieren

32

void pull_ups_fuer_sid_ausschalten(void)

33

{

34

  AT91C_BASE_PIOA->PIO_PPUDR = 

35

    SID_D0 +

36

    SID_D1 +

37

    SID_D2 +

38

    SID_D3 +

39

    SID_D4 +

40

    SID_D5 +

41

    SID_D6 +

42

    SID_D7 +

43

    SID_CLOCK;

44

}

45

46

void poke(unsigned short adresse, char wert)

47

{

48

49

  // Bits maskieren, die gesetzt werden können

50

  p_pPio->PIO_OWER =

51

    SID_A0 +

52

    SID_A1 +

53

    SID_A2 +

54

    SID_A3 +

55

    SID_A4 +

56

    SID_D0 +

57

    SID_D1 +

58

    SID_D2 +

59

    SID_D3 +

60

    SID_D4 +

61

    SID_D5 +

62

    SID_D6 +

63

    SID_D7;

64

65

  // Datenleitung

66

  p_pPio->PIO_ODSR = 

67

    (((adresse & 1)/1)    * SID_A0) +

68

    (((adresse & 2)/2)    * SID_A1) +

69

    (((adresse & 4)/4)    * SID_A2) +

70

    (((adresse & 8)/8)    * SID_A3) +

71

    (((adresse & 16)/16)  * SID_A4) +

72

73

    (((wert & 1)/1)      * SID_D0) +

74

    (((wert & 2)/2)      * SID_D1) +

75

    (((wert & 4)/4)      * SID_D2) +

76

    (((wert & 8)/8)      * SID_D3) +

77

    (((wert & 16)/16)    * SID_D4) +

78

    (((wert & 32)/32)    * SID_D5) +

79

    (((wert & 64)/64)    * SID_D6) +

80

    (((wert & 128)/128)    * SID_D7);

81

82

    p_pPio->PIO_CODR = SID_CS;

83

    wait_sid_cycles(2);      

84

    p_pPio->PIO_SODR = SID_CS;

85

}

86

87

void wait_sid_cycles(int cycles)

88

{

89

  while (cycles != 0)

90

  {

91

    while(!((p_pPio->PIO_PDSR) & SID_CLOCK))

92

    {

93

    }

94

    while(((p_pPio->PIO_PDSR) & SID_CLOCK))

95

    {

96

    }

97

    cycles--;

98

  }

99

}

100

101

void sid_reset(void)

102

{

103

  p_pPio->PIO_CODR = SID_RES;

104

  wait_sid_cycles(20);      // must wait at least 10 SID cycles

105

  p_pPio->PIO_SODR = SID_RES;

106

107

  p_pPio->PIO_CODR = SID_RW;    // our SID is write only

108

  p_pPio->PIO_SODR = SID_CS;    // CS High, Low on read / write

109

}

110

111

int main(void)

112

{

113

  // init leds / usart0

114

  InitPeriphery();

115

  pull_ups_fuer_sid_ausschalten();

116

117

  p_pPio->PIO_CODR = LED1;

118

119

  AT91C_BASE_PIOA->PIO_PDR  = SID_CLOCK;  // Configure SID_CLOCK to be driven by peripheral

120

  AT91C_BASE_PIOA->PIO_OER  = SID_CLOCK;  // Configure SID_CLOCK as output

121

  AT91C_BASE_PIOA->PIO_PPUDR  = SID_CLOCK;  // Disable pull-up on SID_CLOCK

122

  AT91C_BASE_PIOA->PIO_BSR  = SID_CLOCK;  // Assign SID_CLOCK to peripheral B function

123

124

  AT91C_BASE_PMC->PMC_SCER |= 0x00000100;    // Enable PCK1

125

  AT91C_BASE_PMC->PMC_PCKR[0] = 1 + 16 ;    // Select Main Osc Output + Slow Clock

126

127

  // SID Reset erst möglich, nachdem Takt steht.

128

  sid_reset();

129

130

  while(1)

131

  {

132

    poke(0xD418, 15);

133

    p_pPio->PIO_CODR = LED1;

134

    wait_sid_cycles(100000);

135

    poke(0xD400, 196);

136

    p_pPio->PIO_SODR = LED1;

137

    wait_sid_cycles(100000);

138

    poke(0xD401, 9);

139

    p_pPio->PIO_CODR = LED1;

140

    wait_sid_cycles(100000);

141

    poke(0xD405, 94);

142

    p_pPio->PIO_SODR = LED1;

143

    wait_sid_cycles(100000);

144

    poke(0xD406, 71);

145

    p_pPio->PIO_CODR = LED1;

146

    wait_sid_cycles(100000);

147

    poke(0xD404, 33);

148

    p_pPio->PIO_SODR = LED1;

149

    wait_sid_cycles(100000);

150

151

    while(1)

152

    {

153

    }

154

  }

155

}

Sieht eigentlich gut aus der Code, nur daß ich "*" und "/" durch 
Shift-Operatoren (>> und <<) ersetzen würde (Operator-Präzedenz dabei 
beachten).

In so einem Fall würde ich mit einem Scope nachmessen, ob alles auch so 
ist, wie es sein soll, also liegen tatsächlich 1 MHz an? Kommen alle 
Signale wie erwartet nach dem Chipselect? Sind alle Pins am SID 
angeschlossen und alle Pegel richtig? usw. Das Picoscope 3206, was ich 
hier habe (und zwei Kanäle brauchst du, um z.B. die Signale relativ zum 
Chipselect oder Clock zu testen), kann ich wirklich empfehlen. Für dich 
würde allerdings auch die preiswertere 2203-Variante ausreichen, falls 
du nicht irgendwann mal was schnelleres messen willst.

Hi,

hast du schon den 1 MHz mal mit der Programmierung am SID getestet?
Vielleicht sind die 1,xx (s.o.) doch etwas zu hoch.

Stephan

Nein, der Punkt kennzeichnet Pin 1. Wenn der links unten ist, dann ist 
der Ausgang rechts oben. Stromversorgung dann wie bei den meisten 
TTL-Chips: Links oben plus und rechts unten Masse.

Gute Nacht zusammen,

naja, bin echt gefrustet. Habe eben den 1MHz Oszillator angeschlossen. 
Nochmal mit meiner LED-Leiste alle Leitungen zum SID geprüft. Scheint 
so, als ob nix verdreht wäre. Allerdings das Selbe in grün. Nur ein 
Knacksen. Habe extra nochmal die Sound-Befehle im C64 Emulator getestet. 
Da sollte ein gleichmäßiger Ton rauskommen.

Ich denke, dass es irgendwie schon funktioniert. Wenn ich die Lautstärke 
über 0xD418 auf 15 setze, dann knackst es stärker, als wenn ich die 
Lautstärke auf 7 setze. Ich habe noch vom C64 in Erinnerung, dass da ein 
Kancksen war, wenn man die Lautstärke gesetzt hat. Bin mir allerdings 
nicht ganz sicher, ob das beim 8580 auch noch so war...

Hmmm was nun?

Kann es vielleicht an den Kondensatoren für die 2 Filer liegen?

Irgendwie habe ich das Gefühl, dass das mit der Lautstärke klappt, aber 
keine Töne erzeugt werden können...

Das wars dann wohl?

Peter

Hallo NG,

nochmal ein kleiner Nachtrag:

es scheint doch zu funktionieren. Allerdings habe ich wohl folgendes 
großes Problem: Sobald ich auf den SID zugreife entstehen scheinbar 
alleine durch den Zugriff Störgeräusche am Ausgang (ein Knacksen pro 
Zugriff). Habe eine Schleife am Ende Eingebaut, die die Frequenz des 
Tones erhöht. Im Hintergrung hört man diesen Ton ganz Leise. Im 
Vordergrund entsteht ein kontinuierlicher Ton durch die Störgeräusche 
beim Setzen der Leitungen am SID...

Momentan sieht der Code so aus:

1

#include "Board.h" 

2

#include "AT91SAM7S256.h"

3

4

#define LED1    BIT17

5

#define LED2    BIT18

6

#define BUTTON1    BIT19

7

#define BUTTON2    BIT20

8

9

#define SID_A0    BIT0

10

#define SID_A1    BIT1

11

#define SID_A2    BIT2

12

#define SID_A3    BIT3

13

#define SID_A4    BIT4

14

#define SID_RES    BIT5

15

#define SID_CLOCK  BIT6

16

#define SID_RW    BIT7

17

#define SID_CS    BIT8

18

19

#define SID_D0    BIT16

20

#define SID_D1    BIT23

21

#define SID_D2    BIT26

22

#define SID_D3    BIT27

23

#define SID_D4    BIT28

24

#define SID_D5    BIT29

25

#define SID_D6    BIT30

26

#define SID_D7    BIT31

27

28

#include "system.h"

29

#include "system.c"

30

31

// Pullups für die Datenleitungen und die Taktleitung deaktivieren

32

void pull_ups_fuer_sid_ausschalten(void)

33

{

34

  AT91C_BASE_PIOA->PIO_PPUDR = 

35

    SID_D0 +

36

    SID_D1 +

37

    SID_D2 +

38

    SID_D3 +

39

    SID_D4 +

40

    SID_D5 +

41

    SID_D6 +

42

    SID_D7 +

43

    SID_A0 +

44

    SID_A1 +

45

    SID_A2 +

46

    SID_A3 +

47

    SID_A4 +

48

    SID_CLOCK;

49

}

50

51

void poke(unsigned char adresse, char wert)

52

{

53

  // Bits maskieren, die gesetzt werden können

54

  p_pPio->PIO_OWER =

55

    SID_A0 +

56

    SID_A1 +

57

    SID_A2 +

58

    SID_A3 +

59

    SID_A4 +

60

    SID_D0 +

61

    SID_D1 +

62

    SID_D2 +

63

    SID_D3 +

64

    SID_D4 +

65

    SID_D5 +

66

    SID_D6 +

67

    SID_D7;

68

69

  wait_sid_cycles(1);

70

  // Datenleitung

71

  p_pPio->PIO_ODSR = 

72

    (((adresse & 1)/1)    * SID_A0) +

73

    (((adresse & 2)/2)    * SID_A1) +

74

    (((adresse & 4)/4)    * SID_A2) +

75

    (((adresse & 8)/8)    * SID_A3) +

76

    (((adresse & 16)/16)  * SID_A4) +

77

78

    (((wert & 1)/1)      * SID_D0) +

79

    (((wert & 2)/2)      * SID_D1) +