Datenbank in C erstellen

Ja, aber je nach geforderten Funktionen/Performance/Datensicherheit/... 
ist "einfach" relativ.

Was hast du denn für Anforderungen?

Eigentlich kannst du jede Datenstruktur irgendwie zu einer Datenbank 
formen. Der einfachste Fall wäre zum Beispiel ein Array von structs in 
C. Die kannst du dann im Speicher ablegen und via Index darauf 
zugreifen. Da fehlt dir dann natürlich eine komfortable Abfragesprache, 
wie SQL. Das ist auf einem µC aber sowieo overkill...

Gruß
Marius

Zur Not könnte man SQLite verwenden. Ist reines C und eigentlich
überall einbindbar.

ich würd eher sagen, es geht hier um ein (statisches?) config-file

dass per ethernet (ab und zu) mal updated werden soll ??

Ich soll den Microcontroller LM3S6918 programmieren.

Dieser soll funktionieren, ohne dass entweder PC oder sonstiges 
angeschlossen ist.

Die Datenbank soll persistent abgespeichert werden und sollte von außen 
über Touchscreen verändert werden können.

Und das Programm selber soll auch auf die Datenbank zugreifen können und 
die Werte auslesen.

ist das eine Hausaufgabe?

Nein, ein kleiner Teil von meiner Diplomarbeit ;)

Patrick schrieb:
> Ja, das macht Sinn. Zumindest fällt mir spontan kein Anwendungsfall ein,
> bei dem es Sinn macht, die Daten so abzulegen, dass sie nicht gelesen
> und/oder darauf zugegriffen werden kann.

Nie vom WOM gehört ? (Write Only Memory. 8 Dioden auf einen C ;))

Patrick schrieb:

> Soso... Eine Datenbank mit Touch-Interface? - Also... Die Datenbanken,
> die ich so kenne, kommunizieren in der Regel via TCP... Darauf hat's in
> der Regel einen SQL-Dialekt oder (z. B. bei diversen NoSQL-DBs) eine
> HTTP-API. Es gibt natürlich auch Varianten mit z. B. nativem C-API...

das wesentliche ist, dass ich keine andere Verbindung habe, mit der ich 
auf eine Datenbank zugreifen kann.

Deshalb denke ich mir, dass SQL nicht funktionieren wird oder?

Thomas O. schrieb:
> Deshalb denke ich mir, dass SQL nicht funktionieren wird oder?

Warum? Mit sqlite hast du ein Datenbank-File auf dem Board, keinen 
Serverdienst oder Netzwerk.
Dein Programm öffnet (mit Hilfe der SQLite-Library) einfach das File und 
kann darauf SQL-Kommandos ausführen.

Das File kannst du zum Bearbeiten einfach auf den PC kopieren, und dort 
mit den SQLite-Tools, ODBC-Treiber usw. verändern und zurückkopieren.

Aber, je nachdem was du wirklich brauchst: Vielleicht reicht auch ein 
simples Textfile mit linearer Suche?

Thomas O. schrieb:
> Deshalb denke ich mir, dass SQL nicht funktionieren wird oder?

Doch, und zwar in Form von SQLite. Das ist eine in reinem C geschriebene 
SQL-Datenbank, die ihre Daten wahlweise in einem Dateisystem oder aber 
eben auch im Arbeitsspeicher ablegen kann. Da sind keine eigenständigen 
Datenbankprozesse, keine Interprozesskommunikation und erst recht 
keinerlei Netzwerkzugriffe erforderlich.

SQLite braucht sehr wenig Code und ist vorzüglich für den Einsatz in 
Embedded Systems geeignet.

Dann werde ich das mal mit SQLite versuchen :)

Danke an alle für die tolle Hilfe :)


Wenn ich dann noch fragen hab, meld ich mich dann einfach nochmal ;)


Mfg. Thomas

>Studiengang?

mit 19

das ist eine HTL!

Was für Daten sollten denn überhaupt gespeichert werden?
Irgendwie erscheint mir der Begriff "Datenbank" fehl am Platze...

Robert L. schrieb:
>>Studiengang?
>
> mit 19
>
> das ist eine HTL!

Und ich wünschte sie würden aufhören das ganze 'Diplomarbeit' zu nennen.

Aber abgesehen davon hatten wir hier auch schon Diplomanden und sogar 
Doktoranden, die sich auch nicht besser angestellt haben.

Die Frage, die sich mir so stellt, lautet: Braucht es überhaupt eine 
relationale Datenbank? Ich werde das Gefühl nicht los, dass hier (aus 
Unkentniss seitens des Fragestellers) versucht wird, mit Kanonen auf 
Spatzen zu schiessen.

whose 93 schrieb:
> Sry das ich mich auch ins Gespräch einklinke, aber ich arbeite mit
> Thomas O. zusammen:
>
> Es geht darum einfachen Haushalts-Geräten Prioritäten zuzuordnen, mit
> denen dann unser main-Programm arbeiten soll.
> Wir brauchen eine Datenbank, um neue Geräte ein oder austragen zu
> können, bzw. Prioritäten zu änder.

Dazu braucht man eine Datenbank?

Das ist eine simple lineare Liste oder Array, wenns hochkommt ein 
binärer Baum, damit man bei 10000 Geräten schneller suchen kann.

Da habt ihr mit der Portierung von SQLite mehr Arbeit, als wenn ihr 
einfach eure Kentnisse von Datenstukturen auspackt.

Hinweis:

In der Programmierung bezeichnet man oft etwas hochtrabend als 
"Datenbank", was in Wirklichkeit einfach nur eine Sammlung von Daten 
darstellt. Datenbank ist hier (sofern der Begriff in der 
Aufgabenstellung vorkommt) als mehr als die Sammlung der Nutzdaten zu 
sehen.

struct Person
{
  char Vorname[50];
  char Nachname[100];
}

struct Person Belegsschaft[2000];

ist so gesehen schon eine "Datenbank". Es ist die Sammlung der Daten der 
Belegschaft einer Firma.

An das, was Hr. Müller da draussen aber als "Datenbank" (zb Access, zb 
SQL) kennt, werden zusätzlich noch ganz andere Anforderungen gestellt. 
Das hat mit der einfachen Datensammlung von da oben nur sehr wenig zu 
tun, auch wenn man natürlich den Aufwand treiben kann, eine SQL 
Datenbank nur zur Speicherung dieser Daten einzusetzen (was manchmal 
sogar tatsächlich Sinn machen kann).

Aber wie sinnvoll es ist, erst mal Tage damit zu verbringen, eine echte 
relationale Datenbank auf ein System zu portieren, nur um dann 
festzustellen, dass man die Anpassung ans Filesystem sowieso wieder 
selber machen muss, anstatt so ein Array einzusetzen und das von einem 
File zu lesen und zu schreiben (oder in Form eines Cache immer nur Teile 
im Speicher zu haben), das möchte ich jetzt erst mal in Frage stellen.

Ich habe jetzt einfach eine Struktur erstellt, dass mit dem umschreiben 
in der Struktur von außen mach ich später noch, aber das habe ich 
einmal:


  struct Geraete *G
  {
     int Geraetenummer;
    char Name[50];
    unsigned char Geraetleistung[20];
  };

  struct Geraete Geraet1 =
  {
    0,
    "Testgeraet1",
    "50"
  };

  struct Geraete Geraet2 =
  {
    1,
    "Testgeraet2",
    "100"
  };

Aber mein Problem ist jetzt der Zeiger..

Ich möchte mit meinem Programm alle Gerätenummern durchlaufen lassen, um 
zu  sehen ob irgendein Gerät weniger Leistung benötigt als ich momentan 
zur Verfügung habe, damit ich dieses dann einschalten kann. Und das 
solange ich mehr Leistung zur Verfügung habe, als das Gerät verbraucht.


Wenn ich das mit dem Zeiger so mache:

G->Geraetenummer = 0;

kommt der Fehler:

ILOGS.c(348): error:  #132: expression must have 
pointer-to-struct-or-union type


Wahrscheinlich ist der Fehler für ein paar von euch eh offensichtlich, 
aber ich habe vorher eigentlich nie programmiert und bin noch relativ 
unerfahren darin ;)

Hoffe, dass ihr mir helfen könnt..

Mfg.Thomas

Du musst wie es oben schon steht ein Array deiner Struktur anlegen.
Über dieses kannst du dann iterieren.

Thomas O. schrieb:
> Wahrscheinlich ist der Fehler für ein paar von euch eh offensichtlich,
> aber ich habe vorher eigentlich nie programmiert und bin noch relativ
> unerfahren darin ;)

Ja.

G zeigt auf nichts. Du solltest Geraete als Array definieren, in
etwa so:

1

 struct Geraete Ger[] =

2

  { 0, "Testgeraet1",  "50",

3

    1, "Testgeraet2", "100",

4

    0, NULL, 0

5

  };

dann geht auch G = Ger[0].

Danke :)

Werd ich gleich mal ausprobieren ;)

Joachim Drechsel schrieb:
>

1

>  struct Geraete Ger[] =

2

>   { 0, "Testgeraet1",  "50",

3

>     1, "Testgeraet2", "100",

4

>     0, NULL, 0

5

>   };

6

>

>
> dann geht auch G = Ger[0].

und wie kann ich dann auf die Leistung zugreifen?

'tschullung, Tippfehler.

Es muß heißen: G = &Ger[0].

Zugriff: Ger[0].Geraetleistung

zB strcpy( Ger[0].Geraetleistung, "lau");

Wenn ich dass jz so schreibe:

  struct Geraete
  {
     int Geraetenummer;
    char Name[50];
    unsigned char Geraetleistung[20];
  };

  struct Geraete Ger[] =
    {
    0, "Testgeraet1",  "50",
              1, "Testgeraet2", "100",
->(83)           0, NULL, 0
    };

kommt der Error:

ILOGS.c(83): error:  #144: a value of type "void *" cannot be used to 
initialize an entity of type "char"
ILOGS.c(83): error:  #29: expected an expression


und wenn ich das schreibe:

  G = &Ger[0];

kommt der Error:

ILOGS.c(370): error:  #513: a value of type "struct Geraete *" cannot be 
assigned to an entity of type "int *"


und wenn ich das mache:

}while (Leistung >= Ger[0].Geraeteleistung);

ILOGS.c(376): error:  #136: struct "Geraete" has no field 
"Geraeteleistung"

ah, danke ;)

Was mir hier nicht gefällt

1

  struct Geraet

2

  {

3

     int Geraetenummer;

4

    char Name[50];

5

    unsigned char Geraetleistung[20];

6

  };

diese Struktur beschreibt nicht mehrere GeräteE, sondern 1 Gerät. Daher 
sollte man die Struktur auch so benennen!

Das mag dir jetzt lächerlich vorkommen, bei komplexeren Programmen sind 
solche Kleinigkeiten aber wichtige Hilfen, die dir dabei helfen, den 
Programmtext zu überblicken.

Ein Gerät hat eine Nummer - die Gerätenummer. Das es sich dabei um die 
Gerätenummer handelt ist implizit schon dadurch gegeben, dass die Nummer 
eben zu einem Gerät gehört. Du brauchst daher die Variable nicht 
Geraetenummer oder Geraeteleistung nennen. Der Namensteil "Geraet" ist 
schon dadurch ausgedrückt, dass beides Teil der Struktur "Geraet" sind.

1

struct Geraete

2

{

3

  int           Nummer;

4

  char          Name[50];

5

  unsigned char Leistung[20];

6

};

das reicht völlig. Denn wenn du ein konkretes Gerät hast

  struct Geraet Staubsauger;

dann hat dieser Staubsauger eine Nummer und eine Leistung

  Staubsauger.Nummer = 234;
  strcpy( Staubsauger.Leistung, "800 Watt" );

und du befreist dich damit von vieler Tipparbeit, die im Grunde nichts 
bringt.

(Und warum die Leistung ein Array of unsigned char sein soll, musst du 
mir auch erst mal erklären. Wenn etwas zumindest im Prinzip ein 
Zahlenwert ist, dann speichere den auch als Zahlenwert).

Karl Heinz Buchegger schrieb:
> Was mir hier nicht gefällt
>
>

1

> 

2

>   struct Geraete

3

>   {

4

>      int Geraetenummer;

5

>     char Name[50];

6

>     unsigned char Geraetleistung[20];

7

>   };

8

> 

9

>

>
> diese Struktur beschreibt nicht mehrere GeräteE, sondern 1 Gerät. Daher
> sollte man die Struktur auch so benennen!

ist schon umbenannt ;)

Danke

Könntest du mir vielleicht mit den anderen Errors auch helfen? ;)

struct Geraete Ger[] =
    {
    0, "Testgeraet1",  "50",
              1, "Testgeraet2", "100",
->(83)           0, NULL, 0
    };


Du kannst hier nicht NULL nehmen!
Ein Array kann nicht NULL sein. Aber ein String kann leer sein


struct Geraet Geraete[] =
{
  {  0, "Testgeraet1",  "50" },
  {  1, "Testgeraet2", "100", },
  {  0, "", "" }
};

Danke, jz is der Error auch weg ;)

Karl Heinz Buchegger schrieb:
> Du kannst hier nicht NULL nehmen!
> Ein Array kann nicht NULL sein. Aber ein String kann leer sein

Strenggenommen ja ...

Ich verwende solche Strukturen etwas anders.

1

struct Geraete

2

{

3

  int           Nummer;

4

  char          *Name;

5

  char          *Leistung;

6

};

Die Reservierung von Speicher in Form eines Array macht nur Sinn
wenn sich dessen Größe ändert.

Das mit der Struktur dürfte bei mir jetzt passen:

  struct Geraet
  {
     int Geraetenummer;
    char Name[50];
    unsigned char Geraeteleistung[20];
  };

  struct Geraet Ger[] =
    {
    0, "Testgeraet1",  "50",
      1, "Testgeraet2", "100",
      0, "", ""
    };

Aber..

wenn ich das dann schreibe:

         G=&Ger[0].Geraetenummer;
->(371)  L=&Ger[0].Geraeteleistung;

         do{

         G++;

->(377)  }while (Leistung >= L);

kommt dieser Error:

ILOGS.c(371): error:  #513: a value of type "unsigned char (*)[20]" 
cannot be assigned to an entity of type "unsigned char *"
ILOGS.c(377): error:  #42: operand types are incompatible ("unsigned 
char" and "unsigned char *")


was ist der Unterschied überhaupt zwischen unsigned char und unsigned 
char *?

Joachim Drechsel schrieb:

> Ich verwende solche Strukturen etwas anders.
>
>

1

> struct Geraete

2

> {

3

>   int           Nummer;

4

>   char          *Name;

5

>   char          *Leistung;

6

> };

7

>

Sreng genommen hast du hier aber auch kein Array mehr, sondern einen 
Ankerpunkt (den Pointer) an den du ein Array anhängen kannst.
(Im Sinne der Fähigkeiten des TO würde ich ihm allerdings davon abraten. 
Er hat schon genug mit anderen Dingen zu tun)

Thomas O. schrieb:

> was ist der Unterschied überhaupt zwischen unsigned char und unsigned
> char *?


* Warum verwendest du Pointer, wenn du nicht weißt wie man mit ihnen
  arbeitet

* denkst du nicht, dass bei einer Abschlussarbeit für die du einen
  Befähigungsnachweis bekommst, es schon ein bischen spät ist, sich
  in die Grundlagen einzuarbeiten?



wenn du ein Array hast

  double  a[10];

und eine einzelne Variable;

  double k;

dann kannst du mit

  k = a[3];

dir eine Kopie des Wertes aus a (von einem bestimmten Element aus dem 
Arrays) nach k holen.

Das ist bei einer Struktur bzw. einem Array aus Strukturelementen auch 
nicht anders.

struct xy
{
  double x;
  double y;
}

struct xy Punkte[10];


Punkte ist ein komplettes Array von xy-Objekten. Ein einzelnes Element 
aus diesem kompletten Arrray wäre

   Punkte[3]

Das beschreibt also 1 Element aus den 10. Dieses 1 Element ist ein 
struct xy Objekt. Und als solches verfügt dieses eine xy-Objekt 
natürlich über einen x Member und einen y Member. Der x Member ist ein 
double und der y Member ist ein double.

D.h. man kann schreiben

  struct xy Mittelpunkt;     // ein komplettes xy Objekt

  xy = Punkte[3];     // Kopie des kompletten xy Objektes in
                      // die Variable Mittelpunkt ablegen

oder auch

  double mx;
  double my;

  mx = Punkte[3].x;
  my = Punkte[3].y;


Ist alles völlig logisch und folgt daraus, wenn man sich überlegt, was 
man durch die Schreibweise beschrieben hat

1

  Punkte         ist ein komplettes Array von xy Objekten

2

  Punkte[3]      ist ein spezifisches Objekt aus diesem Array

3

  Punkte[3].x    ist ein Member eines spezifischen Objektes aus dem Array

Karl Heinz Buchegger schrieb:

> wenn du ein Array hast
>
>   double  a[10];
>
> und eine einzelne Variable;
>
>   double k;
>
> dann kannst du mit
>
>   k = a[3];
>
> dir eine Kopie des Wertes aus a (von einem bestimmten Element aus dem
> Arrays) nach k holen.

Der Adress Of Operator, liefert dir die Speicheradresse eines Objektes.

Wenn also
  a[3]
ein Element eines Array darstellt, dann ist

  &a[3]

die Adresse des Objektes, wo es im Speicher liegt.

DIese Adresse kann man nun hernehmen und in einer Variablen ablegen, die 
dazu geschaffen ist, Speicheradressen zu speichern - ein sog. Pointer

  double * AdrOfElement = &a[3];

Zusätzlich zu der Information, dass es sich bei AdrOfElement um eine 
Variable handelt, die eine Speicheradresse beinhaltet (ausgedrückt durch 
den *), hält AdrOfElement noch eine weitere Information. Nämlich, dass 
an dieser Stelle im Speicher in double Wert liegt.


Folgerichtig, kann man sich mittels

  struct xy * pMittelPkt;

eine Pointervariable einrichten, die auf ein struct xy Objekt zeigen 
kann.

  Punkte[3];

wäre so ein Objekt. Es besitzt, wie alles, eine Adresse im Speicher, 
welche man mittels

  &Punkte[3]

bekommt.
Und diese Adresse kann man in pMittelPkt ablegen lassen.

 pMittelPkt = &Punkte[3];


Man hat also so etwas gebaut

  pMittelPkt
  +------+                  Punkte
  |  o--------------+       +--------------+
  +------+          |       | x:           |
                    |       | y:           |
                    |       +--------------+
                    |       | x:           |
                    |       | y:           |
                    +------>+--------------+
                            | x:           |
                            | y:           |
                            +--------------+
                            | x:           |
                            .              .
                            .              .

pMittelPkt ist NICHT das struct xy Objekt selber. Es ist ein Verweis auf 
ein struct xy Objekt. Und dieses Objekt steckt seinerseits im Array.

Die Adressierung zb des x Members über diesen Pointer würde so aussehen


  pMittelPkt                der Pointer
  *pMittelPkt               das Objekt, auf welches pMittelPkt zeigt
                            also das struct xy Objekt
  (*pMittelPkt).x           von diesem Objekt der x Member

Da man diese Operation aber häufig braucht und die Schriebweise mit den 
Klammern Tippaufwand bedeutet, gibt es eine alternative Syntax

  pMittelPkt->x             der x Member des Objektes, auf welches
                            pMittelPkt zeigt.

Sieh es im Kontext der Zeichnung so an

  pMittelPkt               suche das Kästchen über dem pMittelPkt steht
  pMittelPkt->             von dort geht ein Pfeil aus, folge dem Pfeil
  pMittelPkt->y            der Pfeil endet bei einem Kästchen, in dem
                           es einen y Member geben muss. Nimm den Wert
                           von diesem y Member.

meine fresse schrieb:
> Hat da vielleicht jemand darüber nachgedacht, zunächst die Anforderungen
> an das "Werk" zu formulieren?

Ich denke, so weit sind sie noch lange nicht.

Es ist das klassische 'Ich hab mich in meinen Fähigkeiten übernommen' 
Syndrom.
Warum man sich das immer wieder antut, eine Abschlussarbeit in einem 
Themenkreis zu suchen, von dem man wenig bis keine Ahnung hat und erst 
mal Grundagen durcharbeiten müsste, wird mir auf ewig ein Rätsel 
bleiben. Ich wähl mir für einen Abschluss ja auch kein Thema, welches 
die fehlerfreie Ausführung einer Blinddarm Operation erfordert, wenn ich 
noch nie ein Skalpell in der Hand hatte und ich mit Ach und Krach gerade 
mal ein Pflaster richtig anbringen kann.

Was das alles mit einer richtigen relationalen Datenbank geworden wäre, 
darüber will ich lieber erst gar nicht nachdenken. Da ist sicherer 
Umgang mit Pointern und/oder Strings mehr oder weniger Pflicht. Sonst 
kannst du dir gleich die Kugel geben.

So haben sie wenigstens die Chance etwa funktionierendes auf die Beine 
zu stellen, wenn auch die Performance leiden wird. Aber lieber ein 
langsameres Programm das funktioniert, als ein Superschnelles welches 
falsche Ergebnisse bringt.

> Einzelne Kompilerfehler zu "unterdrücken" hilft da recht wenig.

Dem stimme ich allerdings uneingeschränkt zu.

Zu wissen an welchem Ende des Schraubenziehers es weh tut, reicht
auch nicht, einen Motor instandzusetzen.

Ohne irgendwelche Grundlagen und einiges an Erfahrung kann das nichts
werden, schom gar keine Abschlußarbeit.

Irgendwann, während meines Studiums, haben wir auch mal verkettete 
Listen in C programmiert. Wenn du also nicht weißt, wieviele Geräte es 
mal gibt und das dynamisch handhaben möchtest, solltest du mal Google 
nach "c list" (oder äahnlich) befragen.

btw.: Was macht eigentlich der Gerät?

http://www.google.at/search?q=%22der+ger%C3%A4t%22&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:de:official&client=firefox-a

Ohne diese Grundkenntnisse reicht das bestenfalls für ein Diplom in Jura 
...

Ich kann nur aus eigener Erfahrung sagen, man lernt C nicht in 2 Wochen.

meine fresse schrieb:
> "ich möchte einem Patienten Blinddarm rein
> laparoskopisch übers Ohr entfernen... bin aber unentschieden, ob ich
> übers linke oder rechte Ohr gehen soll!"

ist auf jeden Fall mal ein innovativer Ansatz, das sollte man 
konzeptionell weiter ausarbeiten ;-)

guenther schrieb:
> Etwas Gutes hat die Situation jedoch: Der auf vielen Dingen angebrachte
> Hinweis "Made in Germany" erfüllt nunmehr wieder die ihm damals von den
> Inselbewohnern zugedachte Funktion als Warnung vor von hirnentkernten
> Diplomdeppen zusammengeschlonztes Bastelkram, garantiert unausgegoren,
> unerprobt, ständig funktionsgestört, mit idiotischen Bedienkonzept, ...
> aber dafür hoffnungslos überteuert!

Daseinszweck einer Firma ist Geld verdienen, nicht technischer
Fortschritt. Zumindest mittlerweile ...

>ob ich
>übers linke oder rechte Ohr gehen soll!"


das trifft es zu 110% ...


dazu kommt dann noch, dass sie bereits das Skalpell in der Hand haben, 
und schon mal ein paar Probeschnitte gemacht haben..

Seltener Gast schrieb:
> Da ist doch irgendetwas faul ...

der Student?