C Code in AVR umwandeln

[Paavo V. (paavo_v)]

Hallo zusammen,

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) ins AVR Studio 
einfügen? Bzw. was müsste ich tun, damit ich diesen Quellcode 
implementieren kann?

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

Kurze Erklärung: Ich hab ein 64 Bit Muster was ich in meinem µC 
zwischenspeichern will, um es dann an 8 schieberegister 74hc595 zu 
senden.
Mit dem Quellcode erzeuge ich mir ein beliebiges 64 Bit-Muster! Dieses 
soll dann ambesten im Ram gespeichert werden, da dieser beim ATMEGA 32, 
welchen in verwende, ja 2 KByte groß ist. Ich habe im Programm das 64 
Bit Wort in 2 x 32 Bits aufgeteilt. Ist aber eigetnlich nicht notwenig 
oder ist es nicht möglcihe in 64 Bitword direkt im ATEMGA32 abzulegen? 
Wenn es doch möglich sein sollte, wo kann ich es dann ablegen?
Das Bitwort soll Bitweise in die 8 in Reihegeschalteten 595 
reingeschoben werden.

Vielen Dank für´s Durchlesen ich freu mich über jeden Antort!:D

Mfg

//#include <stdio.h>
//#include <stdlib.h>
//#include <conio.h>
//#include <string.h>
//#include <ctime>
//#include <iostream>
//#include <cstdlib>
#include <avr/delay.h>
#include <ctype.h>
#include <avr/io.h>
using namespace std;

string zufallscode()
{
    char table[] = "ABCDEF0123456789";

     srand(time(NULL));
        string salat;

        for (int i=0; i<16; i++)
        {
                int c = rand()%15;
                salat.push_back(table[c]);
        }
      // cout << salat << '\n';
       return salat;
}



int Bitfolge (void)
{
  int i,Bit;
  char Bitfolge[17];
  string Zufall;            //ist noch kein ascii folge
  Zufall = zufallscode();
  char sLOW32[9],sHigh32[9];
  char Nullen[17] = "0000000000000000";
  //char buffer [sizeof(long)*8+1];
  char s64[17], Helfer[17]="";
  long lLow32,lHigh32;
    //printf ("Enter a number: ");
    //  scanf ("%d",&i);
    //  ltoa (i,s64,16);

    zufallscode();
    strcpy (s64,Zufall.c_str());          //(ziel, Quelle) (s64, ausgabewert der funktion oben)
  printf ("hexadecimal: %s\n",s64);
  Nullen[16-strlen(s64)] = '\0';
  strcpy(Helfer,Nullen);
  strcat(Helfer,s64);
  strcpy(s64,Helfer);

  //ltoa (i,s64,2);
  strcpy (sLOW32, s64+8);   //strcpy( Ziel, Quelle)
  s64[8]='\0';              //setze an der 8 stelle des Hexwert
  strcpy (sHigh32,s64);
  lLow32 = strtoul(sLOW32,NULL,16);
  lHigh32 = strtoul(sHigh32,NULL,16);
  

  for(Bit = 0; Bit <= 31 ;Bit++)            

    {
    PORTD |= (1<<PD4) & lHigh32 >> Bit & 1;     // 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
    
  }
 for(Bit = 0; Bit <= 31 ;Bit++)              

  {
    PORTD |= (1<<PD4) & lLow32 >> Bit & 1;     // 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
  
  }

}

[Peter II (Gast)]

das ist kein C sonder C++

using namespace std;
String


wirst du auf dem kleinen µC vergessen können, schreibe reines C dann 
geht es auch.

[Karl H. (kbuchegg)]

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++

[Paavo V. (paavo_v)]

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

[Karl H. (kbuchegg)]

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

[Peter II (Gast)]

time

ist auch schön auf einem µC - woher soll er denn bitte schön die zeit 
wissen?

[Εrnst B. (ernst)]

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?

[Reinhard #. (gruebler)]

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

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

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Paavo Varniery schrieb:

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:

   string salat;
   :
   salat.push_back(table[c]);

[Paavo V. (paavo_v)]

Ε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!

[Εrnst B. (ernst)]

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.

[Paavo V. (paavo_v)]

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
    }
}
}

[Karl H. (kbuchegg)]

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?

void send_char( uint64_t Bitmuster)
{
  uint8_t n;

  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 );
}

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)

[Paavo V. (paavo_v)]

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.

[Karl H. (kbuchegg)]

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 H. (kbuchegg)]

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?

[kbuchegg (Gast)]

wobei sich ja auch noch die frage erhebt, wozu du da ueberhaupt uint64-t 
brauchst? musst du etwas mit 64  bit berechnen?

[otti (Gast)]

Oh, hier haben wir einen besser ausgebildeten, hochqualifizierten
Spezialisten, der dringend von Bundesregierung und Industrie gesucht und 
angeworben wird gefunden.

[Paavo V. (paavo_v)]

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.

[iTroll (Gast)]

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

AVR Studio ist eine Entwicklungsentgebung, C eine Programmiersprache.

Paavo Varniery schrieb:
> ja ihr habt ja recht c++

Nur weil der Name zweier Programmiersprachen mit dem selben Buchstaben 
anfängt, muss das Zeug noch lange nicht durch den selben Compiler 
passen.