C Code in AVR umwandeln

Paavo Varniery schrieb:

> ich habe eine frage zum AVR Studio 6. Ich hab mir für mein Projekt was
> ich gerade mache ein C Programm geschrieben und will dieses jetzt im AVR
> einfügen. ich bekommen nen Haufen Fehlermeldungen bzgl der includes. Wie
> könnte man diese Bibliotheken (zB include <conio.h>, etc)

Ähm.
Gar nicht?

Um beim Beispiel zu bleiben: conio.h enhtält die Header von 
Konsolenfunktionen, also Dinge wie Cursorsteuerung etc.


Auf einem AVR hast du keine Konsole.
Und wenn du eine hast, dann musst du dir die Konsolenfunktionen selber 
machen, weil deine Hardware nun mal signifikant anders funktioniert als 
die Konsole auf einem PC

> Ich bin noch zimelicher Leie was AVR Studio angeht...sonst immer nur C
> geprogt.

Echt.

>         string salat;
>
....

>                 salat.push_back(table[c]);

glaub ich nicht.
Das ist C++

Hey,

ja ihr habt ja recht c++,sorry. die Conio.h kann ich ja auch locker 
rausschmeissen, da ich kein printf oder sowas verwende:D

Du kannst da eine Menge rauswerfen.

Darf ich vorschlagen, dass du dort anfängst, wo alle anfangen?
Bei den allereinfachsten Grundlagen:
Die DDR Register und welche Bedeutung sie haben
Wie man einen Ausgangspin auf 1 bzw 0 stellt.

Dann hängst du mal 1 LED an einen Pin und spielst mit der.
LED leuchten lassen, LED nicht leuchten lassen, LED blinken lassen.
Dann das ganze mit mehreren LED
Eventuell vielleicht mal ein Lauflicht

Irgendwann kommt dann mal ein Taster dazu.

etc. etc.

Und dann, irgendwann mal, kommt ein Schieberegister.

AVR-GCC-Tutorial

Wow. Wo stammt das Programm her?
Wild per Copy&Paste aus dem Internet zusammengewürfelt? Dabei C und C++ 
Code vermischt?
Und dabei noch die Schlechtest-mögliche variante gewählt? Oder ist das 
ein Scherz?
Per C++-String-Operationen eine Hexadezimal-Schreibweise eines Longs zu 
erzeugen, um diese dann mit einer undurchsichten C - 
strcat/cpy/.../strtoul Orgie in zwei Longs zu verwusten, nur um eine 
Zufallszahl darin abzulegen?

Lass mich raten: Das Programm stammt aus einem anderen Forum(s-Thread), 
und dort hat sich jemand einen Scherz erlaubt?

Peter II schrieb:
> soll er denn bitte schön die zeit wissen?

»Zeit ist das, was man an der Uhr abliest.«
Alberst Einstein

Paavo Varniery schrieb:

1

PORTD |= (1<<PD4) & lHigh32 >> Bit & 1;

Da wäre ich mir jetzt auf Anhieb gar nicht so sicher, was da rauskommt. 
Ich würde da deutlich mehr Klammern nehmen...

Und das ist für einen uC auch nicht schlecht:

1

   string salat;

2

   :

3

   salat.push_back(table[c]);

Εrnst B✶ schrieb:
> Wow. Wo stammt das Programm her?
> Wild per Copy&Paste aus dem Internet zusammengewürfelt? Dabei C und C++
> Code vermischt?
> Und dabei noch die Schlechtest-mögliche variante gewählt? Oder ist das
> ein Scherz?
> Per C++-String-Operationen eine Hexadezimal-Schreibweise eines Longs zu
> erzeugen, um diese dann mit einer undurchsichten C -
> strcat/cpy/.../strtoul Orgie in zwei Longs zu verwusten, nur um eine
> Zufallszahl darin abzulegen?
>
> Lass mich raten: Das Programm stammt aus einem anderen Forum(s-Thread),
> und dort hat sich jemand einen Scherz erlaubt?

Danke für dein gutes Kommentar! Es war wirklich sehr hilfreich!

Paavo Varniery schrieb:
> Es war wirklich sehr hilfreich!

Denk ich mir. Jetzt kannst du dem, der dir diesen Scherz gespielt hat, 
auf die Finger klopfen.

Tipp zum Thema:
Lass das ganze std::string, char[], strcopy, strtoul -Zeuchs weg. Ja, 
alles!
Dann erzeuge dir die Zufalls*Zahlen* als Zahl. Ohne 
String-Zwischenschritt.

Dann gib deine Zahlen Bitweise aus.


Tipp2 dazu: Shift-Operationen mit variabler Shift-Weite mag der AVR 
garnicht gerne.
Lieber jeden Schleifendurchlauf immer das erste Bit der Zahl ausgeben, 
anschließend die ganze Zahl um eins weitershiften.

Ich hab´s jetzt erstmal ganz einfach gemacht...denk ich jedenfalls...

#define F_CPU 8000000
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <inttypes.h>
#define SHIFT_DATA PD4
#define SHIFT_CLOCK PD6
#define SHIFT_REG PD5


void send_char( uint64_t Bitmuster);



ISR(TIMER1_COMPA_vect)
{

  PORTA = PORTA >>1 ;
  if(PORTA == 0x00)
  PORTA = 0x80;
}


int main(void)

{
  uint64_t Bitmuster;
  DDRA |= 0xFF;
  DDRD |= 0xFF;
  //-----------Timer konfigurieren-----------
  TCCR1B |= (1<<WGM12) | (1<<CS11); //CTC Mode mit WGM12,Prescaler von 8 
mit CS11
  //TCNT1 = 64286;
  TIMSK |= (1<<OCIE1A);
  OCR1A =1249;          //Vergleichswert zur Bestimmung von 1,25ms

  TCCR1A |= (1<<COM1A0);

  send_char(Bitmuster);

  sei();

  while(1)
  {



void send_char( uint64_t Bitmuster)
{
  uint8_t n;
  uint64_t Bitmuster[64] 
={0,0,1,0,0,0,0,1,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,1,1,1,0,0,1, 
0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,1,0,1,0,1,1,1};

  for ( n = 0, n <= 64; n++)
    {
      PORTD |= (1<<SHIFT_DATA) & Bitmuster[i];         // Daten auf PD4
      PORTD = PORTD & 0x40;              // Takt auf PD6
    }
      PORTD = 0;                    // Takt und Daten löschen
      PORTD = 0x20;                  //Registerclock
      PORTD = 0;                    // Takt, Daten und LOAD löschen
    }
}
}

Paavo Varniery schrieb:

Was bitte ist an

> void send_char( uint64_t Bitmuster)
> {
>   uint8_t n;
>   uint64_t Bitmuster[64]
> ={0,0,1,0,0,0,0,1,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,1,1,1,0,0,1, 
0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,1,0,1,0,1,1,1};

einfach?

1

void send_char( uint64_t Bitmuster)

2

{

3

  uint8_t n;

4

5

  for( n = 0; n < 64; n++ )

6

  {

7

    if( Bitmuster & 0x01 )

8

      PORTD |= ( 1 << SHIFT_DATA );

9

    else

10

      PORTD &= ~( 1 << SHIFT_DATA );

11

12

    PORTD |= ( 1 << SHIFT_CLOCK );

13

    PORTD &= ~( 1 << SHIFT_CLOCK );

14

15

    Bitmuster >>= 1;

16

  }

17

18

  PORTD |= ( 1 << SHIFT_REG );

19

  PORTD &= ~( 1 << SHIFT_REG );

20

}

Das wäre einfach. Und neben bei bemerkt auch noch richtig, was man von 
deiner Port-Orgie nicht gerade behaupten kann.

Noch einfacher (auch für den AVR) wäre es, eine Funktion zu schreiben, 
die lediglich 8 Bit raustaktet, und die dann einfach 8 mal mit den 
einzelnen Bytes aufzurufen. Sonst schiebt sich der AVR mit den 64-Bit 
Variablen zu Tode (aber ok. so schlimm ist das auch wieder nicht)

Ich will ja aber aus dem Bitmuster[] die einzelnen nullen und einsen 
haben und die rüberschieben!? Also will ich mit der for-Anweisung die 
jeweiligen Einträge des Arrays abarbeiten.

Paavo Varniery schrieb:
> Ich will ja aber aus dem Bitmuster[]

und wozu brauchst du das Array?
Oder bist du Array-Fetischist?

Wozu ein Array aus 64 Stück uint64_t basteln, wenn es ein einziger(!) 
uint64_t auch tut, den man dann eben Bit für Bit raustaktet.


Oder was glaubst du, was die Kombination aus

  for( n = 0; n < 64; n++ )
  {
    if( Bitmuster & 0x01 )
...

    Bitmuster >>= 1;
  }

macht?

Karl Heinz Buchegger schrieb:
> Paavo Varniery schrieb:
>> Ich will ja aber aus dem Bitmuster[]
>
> und wozu brauchst du das Array?
> Oder bist du Array-Fetischist?
>
> Wozu ein Array aus 64 Stück uint64_t basteln, wenn es ein einziger(!)
> uint64_t auch tut

Nur um das ins rechte Licht zu rücken.
Du verbrauchst 64 * 8, gleich 512 Bytes, wo du mit einer 8-Byte Variable 
auch auskommst.
Wieviel SRAM Speicher hat noch mal dein µC?

Karl Heinz Buchegger schrieb:
> Karl Heinz Buchegger schrieb:
>> Paavo Varniery schrieb:
>>> Ich will ja aber aus dem Bitmuster[]
>>
>> und wozu brauchst du das Array?
>> Oder bist du Array-Fetischist?
>>
>> Wozu ein Array aus 64 Stück uint64_t basteln, wenn es ein einziger(!)
>> uint64_t auch tut
>
> Nur um das ins rechte Licht zu rücken.
> Du verbrauchst 64 * 8, gleich 512 Bytes, wo du mit einer 8-Byte Variable
> auch auskommst.
> Wieviel SRAM Speicher hat noch mal dein µC?

2Kbytes Internal SRAM

sollte also langen:D

Ich habe jetzt das uint64_t Bitmuster = 0xDE0BFCE86252724; festgelegt.

Und gebe es mit :

{  for ( n = 0; n <= 64; n++)
      {
        if( Bitmuster & 0x01 )
        PORTD |= ( 1 << SHIFT_DATA );
        else
        PORTD &= ~( 1 << SHIFT_DATA );

        PORTD |= ( 1 << SHIFT_CLOCK );
        PORTD &= ~( 1 << SHIFT_CLOCK );

        Bitmuster >>= 1;
      }

      PORTD |= ( 1 << SHIFT_REG );
      PORTD &= ~( 1 << SHIFT_REG );
    }
  }

aus!

hab´s mal debugt und es sieht ganz gut aus bis darafu, dass mir AVR beim 
bitmuster etwas merkwürdige werte anzeigt! erst kommt wie erwartet eine 
bitfolge von 010101010100010 etc doch dann folgen darauf irgendwie 
dezimal aussehende zahlen...duch &0x01 gucke ich mir ja immer nur das 
erste Bit an(ob 0 oder 1) dann wird es rübergeschickt.