eigene__ ide

Sehe ich das richtig? Du willst in #C eine eigene IDE schreiben?

Da wirst du auf ungefähr 10000 Probleme in der Art .dep/main.o.d stoßen.

Für so eine Aufgabe musst du entweder 50 Entwickler bezahlen oder 1000 
Freiwillige begeistern.

Ein Kommentar schrieb:
> Für so eine Aufgabe musst du entweder 50 Entwickler bezahlen oder 1000
> Freiwillige begeistern.


C:\_zuc_workspace\20211012_wind>make

-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is 
NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.


Size before:
AVR Memory Usage
----------------
Device: atmega328p

Program:     134 bytes (0.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)




Size after:
AVR Memory Usage
----------------
Device: atmega328p

Program:     134 bytes (0.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)



-------- end --------


C:\_zuc_workspace\20211012_wind>


gar nicht so schwierig. Man muss nur den Befehl "make" eingeben - dann 
wird der makefile abgearbeitet.

grundschüler schrieb:
> Ich hätte gerne eine mit c# erstellte eigene ide

Eine eigene IDE? Dann schreib dir eine. Aber gibt es einen triftigen 
Grund, dafür dediziert C# verwenden zu wollen?

Aber mal abgesehen davon, man kann auch die betreffenden Aufrufe der 
Tools in eine Batchdatei (oder bei unixoiden OS in ein Shellscript) 
packen und benötigt dann lediglich einen simplen Texteditor und irgend 
einen Finder oder Explorer, d.h. ein Programm zum Navigieren auf der 
Platte. Das geht und ist nicht wirklich aufwendig. Und es hätte den 
Vorteil, daß man bei jedem Toolaufruf testen kann, ob er geklappt hat - 
und nicht nach einer Elle von unverstandenen Meldungen schlußendlich vor 
der finalen Meldung steht "es geht nicht" und dann hier um Rat fragen 
muß.

W.S.

W.S. schrieb:
> Das geht und ist nicht wirklich aufwendig.

Es kommt immer auf das Maß der Faulheit an - ich bin besonders faul.

Am Anfang ist der makefile. Der enthält nur wenige Einstellungen, die 
Projektabhängig geändert werden müssen:


MCU:
#MCU = atmega328pb
MCU = atmega328p
#MCU = atmega2560
#MCU = atmega1284p
#MCU = atmega644
#MCU = atmega8
#MCU = atmega32

Quelldateien:
# Target file name (without extension).
TARGET = main
SRC = $(TARGET).c
# i2clcd.c i2cmaster.c ds18x20.c onewire.c ds1820_verw.c irint.c 
ir_anwendung.c  std_lib_lcd.c
# ili9320.c


Die c#-Form muss also eine Liste mit Quelldateien enthalten, die durch 
anklicken ausgewählt werden und dann entsprechend im makefile 
automatisch eingetragen werden. Der Inhalt des makefiles muss der 
c#-form bekannt sein.

c# deswegen, weil ich meistens damit arbeite und es besser beherrsche 
als andere Progrnmmierumgebungen.

grundschüler schrieb:
> Es kommt immer auf das Maß der Faulheit an - ich bin besonders faul.
Also zu faul um eine der zahlreichen und äußert erfreulich 
funktionierenden IDEs zu benutzen?
Macht keinen Sinn was Du da schreibst.

Max M. schrieb:
> grundschüler schrieb:
>> Es kommt immer auf das Maß der Faulheit an - ich bin besonders faul.
> Also zu faul um eine der zahlreichen und äußert erfreulich
> funktionierenden IDEs zu benutzen?
> Macht keinen Sinn was Du da schreibst.

Ich kenne winAVr, Eclipse, Bascom, arduino, HAL, und noch ein paar 
andere. Ich denke, es geht deutlich besser.

grundschüler schrieb:
> Ich denke, es geht deutlich besser.

sehr überheblich, vor allem wenn man so ein Feature als IDE ansieht:

grundschüler schrieb:
> Die c#-Form muss also eine Liste mit Quelldateien enthalten, die durch
> anklicken ausgewählt werden und dann entsprechend im makefile
> automatisch eingetragen werden. Der Inhalt des makefiles muss der
> c#-form bekannt sein.

Andere IDE nutzen smartere Build Systeme. Und die ganzen Editor 
Features, git Anbindung, Intellisense usw. baust du schnell in C# 
selber?

grundschüler schrieb:
> Ich kenne winAVr, Eclipse, Bascom, arduino, HAL, und noch ein paar
> andere.

Nichtmal Atmel Studio? Oder CLion? Und du meinst du könntest es besser 
als Firmen, die Jahrzehnte Erfahrung damit haben und hunderte Entwickler 
beschäftigen? Inklusive Späßen wie Code-Vervollständigung 
("IntelliSense"), Debugger-Anbindung, Konfigurations-Management?

grundschüler schrieb:
> Ich kenne winAVr, Eclipse, Bascom, arduino, HAL, und noch ein paar
> andere. Ich denke, es geht deutlich besser.

Respekt. Du wirst deinen Weg machen. Wohin der führt ist allerdings 
unklar.

Klingt interessant.
Hast du eine Übersicht was herkömmlich ungenügend ist, was du verbessern 
willst?

grundschüler schrieb:
> Es kommt immer auf das Maß der Faulheit an - ich bin besonders faul.
Mach dir nix draus. Gibt Schlimmeres.

grundschüler schrieb:
> c# deswegen, weil ich meistens damit arbeite und es besser beherrsche
> als andere Progrnmmierumgebungen.
besser heisst nicht gut.

grundschüler schrieb:
> gar nicht so schwierig. Man muss nur den Befehl "make" eingeben - dann
> wird der makefile abgearbeitet.
Geil. So einfach ist das - du schaffst das (wenn ich mir mal deine 
bisherigen Beiträge angeschaut habe hast du durchaus Kompetenz).

Als nächstes Projekt dann eine Raumfähre - da gibt es ja auch einiges zu 
verbessern.

grundschüler schrieb:
> Am Anfang ist der makefile.

Hmm... Nun wenn du meinst. Aber wenn man ein Make benutzen will, dann 
relativiert sich der Bedarf an einer IDE durchaus.
Ich hatte mir vor langer Zeit mal eine kleine IDE für das Programmieren 
der PIC16 geschrieben, aber diese IDE nie wirklich fertig gemacht. Sie 
hat dennoch bis jetzt ganz gute Dienste geleistet - und das komplett 
ohne Makefile.

Sebastian R. schrieb:
> Ich möchte nicht wissen, wie viele Millionen Zeilen Code so ein Eclipse
> hat.

Das brauchst du auch nicht. Aber man muß ja nicht immerzu nur nach dem 
dicksten Elefanten schielen. Meine o.g. kleine PIC16-IDE ist insgesamt 
nur 1 MB groß. Bzw. klein. Eigentlich benötigen die meisten Leute nur 
einen ordentlichen Editor, eine Startmöglichkeit für den 
Übersetzungsvorgang und ein Brennprogramm, um ihr Ergebnis in den µC zu 
löffeln. OK, all die Leute, die zum vorherigen Denken zu faul oder zu 
doof sind, brauchen obendrein noch einen Debugger, um zu sehen, was da 
eigentlich herausgekommen ist. Andere begnügen sich mit der berüchtigten 
blinkenden LED oder einer seriellen Verbindung zum PC. Da sind die 
Geschmäcker verschieden.

W.S.

W.S. schrieb:
> Eigentlich benötigen die meisten Leute

Immer wieder lustig wie du so genau weißt was andere brauchen.

W.S. schrieb:
> OK, all die Leute, die zum vorherigen Denken zu faul oder zu
> doof sind, brauchen obendrein noch einen Debugger

Da gehörst du doch selbst zu, oder hat du schon vergessen wie du selbst 
deine eigenen Fehler in deinem eigenen USB-Code jahrelang nicht gefunden 
hast aufgrund deiner Debugger-Verweigerung? Du bist echt unbelehrbar!

und heute gibt es zig Editoren die als mehr oder weniger simple IDE 
erweitert werden können, man muss nur mal versuchen zu verstehen was 
andere geschaffen haben.
Den VSCode kann man einfach auf ein Verzeichniss mit Quelltexten 
loslassen und eine C Quellcodedatei öffnen. VSC erkennt C und bietet die 
Installation der C/C++ Unterstützung an, schon hat man Intellisense und 
Einbindung von Headerfiles.
Kurz nach AVR in den Extensions gesucht, da findet man sowas:
https://marketplace.visualstudio.com/items?itemName=Alex079.vscode-avr-helper
Scheint als einfache Erweiterung zum Kompilieren und Flashen für AVR 
Chips zu reichen.

W.S. schrieb:
> OK, all die Leute, die zum vorherigen Denken zu faul oder zu
> doof sind, brauchen obendrein noch einen Debugger

Genau!
Nur Idioten brauchen Anschnallgurte, Airbags, Knautschzone, Kopfstützen 
und eine Pedalerie die einem nicht die Füsse schreddert beim Unfall.
Automatik, Abstandswarner, Tempomat, Notbremsassistent, adaptives 
Kurvenlicht, alles nur für Pussys.
Richtige Kerle können einfach so gut fahren das sie den ganzen Kokolores 
nicht brauchen 😂🤣😂

Und nur totale Versager brauchen ein Radio.
Die richtig geilen Typen singen selbst.

Alles verweichlichte Muttersöhnchen hier.

> Ich denke, es geht deutlich besser.

Lass dich nicht davon abbringen.

Die Leute, die Eclipse, Arduino usw. begannen, dachten auch es geht 
deutlich besser als Emacs oder Vi.

Hätten diese Leute auf "viel zu aufwendig, schaffst du nicht" gehört, 
würden wir heutzutage immer noch Lochkarten stanzen.

viel Spott - wenig ernsthaftes Interesse. Trotzdem hiermal die 
Vorüberlegung zur Textvervollständigung:

1

       private void timer1_Tick(object sender, EventArgs e)

2

            {

3

            int counter=0;

4

             curpos = richTextBox1.SelectionStart;

5

            len = richTextBox1.Text.Length;

6

            if (curpos > 1)

7

                {

8

               abfr = richTextBox1.Text.Substring(curpos - 2, 2);

9

                 label1.Text = abfr;

10

                int i=0;

11

                for (i = 0; i < listBox1.Items.Count; i++) 

12

                    {

13

                        abfr1 = listBox1.Items[i].ToString().Substring(0, 2);

14

                        if (listBox1.Items[i].ToString().Substring(0, 2) == abfr)

15

                            {

16

                            listBox1.SetSelected(i, true);

17

                            counter++;

18

19

                            }

20

                        else

21

                            {

22

                            listBox1.SetSelected(i, false);

23

24

                            }

25

26

27

28

                }//for

29

                     if (counter == 1) 

30

                            twoseconds++;

31

                        else

32

                            twoseconds = 0;

33

34

35

                            }

36

            if (twoseconds >1) 

37

                 {

38

                           //text um 2Zeichen kürzen

39

                 string xx;

40

                 //int curpos;

41

42

43

                                    if (listBox1.SelectedItem.ToString().IndexOf("#") > 0)

44

                                        {

45

                                        int lx = listBox1.SelectedItem.ToString().IndexOf("#");

46

                                        xx = listBox1.SelectedItem.ToString().Substring(4).Replace("#", "") + (char)11;

47

                                     xx=  xx.Replace('|', (char)11);

48

                                         // richTextBox1.Text = xx;

49

                                        //   richTextBox1.SelectionStart =lx-3;

50

                                        richTextBox1.Text = richTextBox1.Text.Substring(0,curpos-2) + xx +  richTextBox1.Text.Substring(curpos);

51

52

53

54

                                        curpos += lx - 6;

55

                                        }

56

                                     else 

57

                                        { 

58

                                        xx=listBox1.SelectedItem.ToString().Substring(4)+(char)11;

59

                                      xx=  xx.Replace('|', (char)11);

60

61

                                       richTextBox1.Text = richTextBox1.Text.Substring(0,curpos-2) + xx +  richTextBox1.Text.Substring(curpos);

62

63

64

                                        curpos += xx.Length -3;

65

66

                                        }

67

                                    richTextBox1.SelectionStart = curpos;

68

69

70

                  }

71

72

            }//tim1

der Timer wertet die Texteingabe aus. Lautet diese z.B. 'fo' wartet der 
timer kurz ab ob noch was kommt - wenn nicht wird gnadenlos 
vervollsatändigt -

for (int i=0;i<;i++)
{

}

- und der Cursor an der durch eine Marke vorgegebenen Stelle 
positioniert.

grundschüler schrieb:
> Lautet diese z.B. 'fo' wartet

Niemand braucht Vervollständigung für for-Schleifen. Viel interessanter 
ist es, Funktionsnamen & Parameter, structs & Elemente und 
Member-Funktionen (C++) vorzuschlagen. Dazu musst du den Code parsen um 
zu wissen, was alles so definiert ist. Und das ist gar nicht so einfach, 
gerade in C++, wenn Meta-Programmierung hinzu kommt. Man kann dafür 
libclang integrieren, aber dann muss man immer noch einen Mehrwert 
gegenüber all den anderen IDEs bieten, die es genau so machen.

Mit timeout zu vervollständigen finde ich fragwürdig - wenn ich eine 
Funktion aufrufen möchte die mit "fo" anfängt, "fo" eintippe, dann doch 
noch über was anderes nachdenke hab ich plötzlich was da stehen was ich 
nicht will. Autovervollständigung sollte die Vorschläge wenn schon in 
einem kleinen Pop-Up darstellen sodass man mit "Return" bestätigen kann. 
Schau dir in Visual Studio, Eclipse oder CLion an wie das üblicherweise 
gemacht wird, denn Entwickler sind daran gewöhnt und erwarten das so.

Wenn du wirklich was innovatives machen willst: Schreib ein Plugin für 
Eclipse um damit Rust auf Embedded Systemen programmieren zu können.

grundschüler schrieb:
> viel Spott - wenig ernsthaftes Interesse

Ja warum nur?
'grundschüler' rafft  make nicht, hat ganz offensichtlich noch niemals 
auch nur an 20% der Leistungsfähigkeit einer modernen IDE gekratzt und 
schickt sich nun an die Welt der IDE fundamental zu revolutionieren.

Das scheint eine Naturkonstante des Universums zu sein.
Je weniger Ahnung und Erfahrung jemand hat umso größer sind seine Pläne 
und umso mehr ist er der Meinung besser zu sein als Leute die das schon 
ihr halbes Leben machen und in großen Teams nicht das geschafft haben 
was sich der Newbi alleine zutraut.

Jemand mit Erfahrung und einer realistischen Sicht auf das was er 
zeitlich und fachlich stemmen kann, würde sich vielleicht an einem OS 
Projekt beteiligen, um die aus seiner Sicht verbesserungswürdigen Dinge 
zu verbessern.

Ein Anfänger will alles auf ein Mal, verzettelt sich in Details, 
verliert erst die Übersicht und dann die Motivation.
Zurück bleibt dann eines dieser unzähligen halbfertigen und 
undokumentierten SW Gerippe mit unwartbarem Code, die niemand braucht, 
niemand will und niemand pflegt.
GIT und unzählige websites sind voll davon.

DU rollst gleich die ganze Welt der IDEs als one man show auf.
Tut mir auch echt leid, wenn mir sowas nur ein müdes Lächeln aufs 
Gesicht zaubert.

oder kurz gesagt: das typische NIH Problem.

Eine meiner ersten bezahlten Taten war auch mal ein make sowie einen 
Debugger für X86  zu schreiben. Das wurde auch >15 Jahre produktiv 
genutzt in einem relativ gut standardisiertem Prozess, aber eben sehr 
proprietär.
Heute würde ich sagen: niemals wieder!

Hallo Herr grundschüler,
ich bräuchte da mal dringend Hilfe bei meiner spaceX. Da geht einiges 
daneben - könnten Sie mir da kurz aushelfen?
Urgend. Call me please.
Elon.

grundschüler schrieb:
> Ich hätte gerne eine mit c# erstellte eigene ide

Jou, mach mal.

Ich hätte gerne eine funktionale IDE. Muss nicht "eigen" sein.

Ich muss zugeben, dass ich in "jungen Jahren" mich auch mal an einer 
"IDE" versucht habe. Allerdings war es nicht die Tausendste IDE für C, 
sondern für die Skriptsprache eines Videospiels. Sie hatte zwar keine 
tollen Features wie Code-Completion, aber hatte diverse Tools und Helfer 
eingebaut für die spezifischen Datenformate des Spiels (z.B. Darstellung 
von Animationen des eigenen Formats, Entpacken der Ressourcen-Dateien). 
Man konnte also nicht wirklich sagen dass es "besser" war als 
existierende IDEs und natürlich hat keiner das je verwendet, aber 
immerhin habe ich viel dabei gelernt, auch über alle möglichen Open 
Source Technologien. Es hat sich also schon irgendwie gelohnt, aber ich 
habe auch nicht direkt zu Anfang im Forum wirre Fragen gestellt ohne 
auch nur ansatzweise ein Konzept zu haben...

Wegen C#: Das ist durchaus eine gute Sprache für sowas. Ich hätte 
vielleicht Java oder Kotlin bevorzugt, weil das besser unter Linux zu 
verwenden ist.

Programmierer schrieb:
> aber ich
> habe auch nicht direkt zu Anfang im Forum wirre Fragen gestellt ohne
> auch nur ansatzweise ein Konzept zu haben...

Da bekommt man ja Angst sich zu blamieren. Ich hab ja irgendwie ein 
Konzept. Umsetzen kann ich es - irgendwie - auch. Nur es tauchen halt 
Fragen auf, die dir als - professionellem(?) - Programmierer dumm 
erscheinen, die aber mich - und mein Programm - weiterbringen.

Ziel sind schnelle Ergebnisse - danach die Feinheiten. Als erstes soll 
ein bewährte i2c-lcd-Programm compiliert und in den uc geladen werden. 
Ich setze also erstmal weitestgehend auf programmers notepad auf und 
benutze den makefile. Nur der Textteil soll über die C#-form eingegeben 
werden.

Der makefile wird vom c#-Programm automatisch geändert:
 makefile_read(path);
            string text = makefiletext.Substring(0, mkf_src_start + 
17)+" ";
            text += item;
            text += makefiletext.Substring(mkf_src_end-1);
            File.WriteAllText(path + "makefile",text);
Das funktioniert.

Problem: ich habe ein Verzeichnis c:\ra_ide\src für bib-Dateien 
angelegt. Eine entsprechende path-Variable gesetzt. Der makefile findet 
die Dateien aber trotzdem nicht. Im makefile Verzeichnispfade anzugeben, 
gelingt mir nicht. Ich kann im Stammverzeichnis aber Dateien anlegen, 
die per include
auf das src-Verzeichnis verweisen. Das funktioniert - erscheint mir aber 
zu umständlich.

Warum funktioniert die Umgebungsvariable nicht?
Wie gibt man im makefile Verzeichnispfade an?

grundschüler schrieb:
> Da bekommt man ja Angst sich zu blamieren. Ich hab ja irgendwie ein
> Konzept.
irgendwie...

grundschüler schrieb:
> Umsetzen kann ich es - irgendwie - auch.
irgendwie...
grundschüler schrieb:
> Ziel sind schnelle Ergebnisse
irgendwie?

Also ne gui zu schreiben - für funktionale cmdline programme - das 
sollte auch ein grundschüler hinbekommen - "irgendwie".
Aber wo ist dein "Konzept" - da sehe ich nur Verwirrung.
Umsetzung - da sehe ich nichts.
Schnelle Ergebnisse - nix zu sehen ausser Fragen.
Was geht denn schon / nicht, wo ist ein preview?
Aber alles besser als vorhandenes...

grundschüler schrieb:
> Da bekommt man ja Angst sich zu blamieren. Ich hab ja irgendwie ein
> Konzept.

Das kommt irgendwie nicht rüber.

grundschüler schrieb:
> Nur es tauchen halt
> Fragen auf, die dir als - professionellem(?) - Programmierer dumm
> erscheinen, die aber mich - und mein Programm - weiterbringen.

Fragen stellen ist gut, aber gerne so dass man sie versteht und die 
Grundidee sichtbar wird...

grundschüler schrieb:
> Der makefile findet
> die Dateien aber trotzdem nicht.

Dann zeig doch mal das generierte Makefile, rufe es manuell per "make" 
auf der cmd auf und zeige die Fehlermeldung... Makefiles schreiben ist 
sowieso eine Kunst, daher ist es erstmal wichtig ein vernünftiges 
Makefile zu produzieren in dem dann automatisch Dateinamen, 
Compiler-Optionen & Co. eingebaut werden.

Walter K. schrieb:

> Erstens gibt es sehr gute Betriebssysteme unter denen C# völlig
> unbekannt ist

Welche sollen das sein? Und jetzt bitte keine historischen Altlasten 
oder Nerd-Spielereien auflisten...

Das Programm ist sicher noch nicht fertig - läuft aber im Prinzip.

Zugriff auf makefile über grafische Oberfläche funktioniert,
make/clean/prog  kann vom Programm gestartet werden,
include von Dateien geht per Mouseclick,
Texterkennung über timer funktioniert auch,

Ob es wirklich brauchbar ist muss sich dann in der praktischen Anwendung 
zeigen.

Da wir gerade bei dem Thema sind...

Die IDE der Xerox Alto war ein Fortschritt gegenüber allen 
vorhergehenden und allen nachfolgenden IDEs.

https://youtu.be/9H79_kKzmFs?t=732

OK - bei der Geschwindigkeit der Hardware gab es in den letzten 50 
Jahren gewaltige Verbesserungen.

Ich habe in ferner Vergangenheit mal mit Dev-C++ so was ähnliches 
gemacht.
In Dev-C++ kann man sehr einfach verschiedene Zielsysteme mit 
verschiedenen Compilern einrichten. Das sollte für die beschriebenen 
Zwecke gut funktionieren.

Das Projekt gibt es scheinbar immer noch:

https://sourceforge.net/projects/orwelldevcpp/

Heinz schrieb:
> In Dev-C++ kann man sehr einfach verschiedene Zielsysteme mit
> verschiedenen Compilern einrichten. Das sollte für die beschriebenen
> Zwecke gut funktionieren.

Das können alle vernünftigen IDEs, wie z.B. Eclipse oder QtCreator und 
natürlich alle die makefiles unterstützen. Geheimtipp: Der Conan.io 
Package Manager macht es einfach, C/C++ Programme mit Bibliotheken für 
verschiedene Systeme zu übersetzen, weil man nicht mehr manuell für 
jedes Zielsystem alle Bibliotheken zusammen suchen/kompilieren muss. 
Damit ist es mir gelungen, von Linux aus ein Programm auf Basis von 
GLFW, Vulkan, Boost und ein paar anderen für die Systeme Linux amd64 und 
arm64, Windows, macOS reproduzierbar(!!) zu (cross)kompilieren. Man muss 
nur conan, gcc, make installieren, mein Makefile mit dem Zielsystem als 
Parameter aufrufen, und conan hat automatisch die Abhängigkeiten exakt 
in der benötigten Version für das Ziel heruntergeladen, ggf. kompiliert, 
und das makefile hat ein fertiges Programm daraus gebaut. Ein riesiger 
Fortschritt gegenüber dem manuellen Zusammenstellen aller Bibliotheken 
für alle Systeme! Java-Entwickler lachen darüber natürlich... Eine IDE 
mit direkter Unterstützung für conan wäre knorke und innovativ, bzw. 
halt als Plugin für Eclipse oder QtCreator.

Ein Kommentar schrieb:
> Die IDE der Xerox Alto war ein Fortschritt gegenüber allen
> vorhergehenden und allen nachfolgenden IDEs.

Tja, Smalltalk konnte sogar OOP. Da sind die C-Fanatiker immer noch 
nicht angekommen. C++ ist ja davon inspiriert...

Walter K. schrieb:

> Alle BSD‘s, wie z.B. FreeBSD, OpenBSD, NetBSD usw.

Das SIND Nerd-Spielereien. Der Marktanteil über alle real genutzten 
OS-Installationen bewegt sich im Promille-Bereich.

Das pn-Ausgabefenster:


> "make.exe" all

-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is 
NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.


Compiling C: main.c
avr-gcc -c -mmcu=atmega328p -I. -gdwarf-2  -Os -funsigned-char 
-funsigned-bitfields -fpack-struct -fshort-enums -Wall -w 
-Wa,-adhlns=./main.lst  -std=gnu99 -MMD -MP -MF .dep/main.o.d main.c -o 
main.o

Compiling C: _std_lib_lcd.c
avr-gcc -c -mmcu=atmega328p -I. -gdwarf-2  -Os -funsigned-char 
-funsigned-bitfields -fpack-struct -fshort-enums -Wall -w 
-Wa,-adhlns=./_std_lib_lcd.lst  -std=gnu99 -MMD -MP -MF 
.dep/_std_lib_lcd.o.d _std_lib_lcd.c -o _std_lib_lcd.o

Linking: main.elf
avr-gcc -mmcu=atmega328p -I. -gdwarf-2  -Os -funsigned-char 
-funsigned-bitfields -fpack-struct -fshort-enums -Wall -w 
-Wa,-adhlns=main.o  -std=gnu99 -MMD -MP -MF .dep/main.elf.d main.o 
_std_lib_lcd.o --output main.elf -Wl,-Map=main.map,--cref     -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom -R .fuse -R .lock main.elf main.hex

Creating load file for EEPROM: main.eep
avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" \
  --change-section-lma .eeprom=0 --no-change-warnings -O ihex main.elf 
main.eep || exit 0

Creating Extended Listing: main.lss
avr-objdump -h -S -z main.elf > main.lss

Creating Symbol Table: main.sym
avr-nm -n main.elf > main.sym

Size after:
AVR Memory Usage
----------------
Device: atmega328p

Program:     134 bytes (0.4% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)



-------- end --------


> Process Exit Code: 0
> Time Taken: 00:02

Das Ergebnis von "make all" kann vom Programm ausgewertet werden - 
main.hex existiert oder existiert nicht. Was mir bisher nicht gelungen 
ist, ist die Umleitung der output-Meldungen in das Programm bzw. in eine 
Datei. Mir ist auch nicht klar, wie die output-Meldung im make-file 
gesteuert wird.

Wäre da für konstruktive Unterstützung dankbar.

grundschüler schrieb:
> Was mir bisher nicht gelungen ist, ist die Umleitung der
> output-Meldungen in das Programm

Du musst den stdout/stderr des make-Prozesses umleiten. Am makefile 
musst du dazu nichts ändern.

https://thedeveloperblog.com/redirectstandardoutput

Wichtig ist dass du kontinuierlich die Daten einliest während make 
läuft, weil es sonst stecken bleiben kann. Das machst du per Asynchronem 
IO ("overlapped IO" in Windows Sprechweise), sodass deine GUI reaktiv 
bleibt. Siehe auch:

https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.standarderror?redirectedfrom=MSDN&view=net-6.0#System_Diagnostics_Process_StandardError

Das ist leider nicht so ganz einfach.

Programmierer schrieb:

Danke

Es geht langsam voran.

Problem Zeilennummerierung - Jedes Programm zur Erstellung von Software 
hat eine Zeilennummerierung. Das sieht so aus, als wäre es vom Text 
getrennt. Wie machen die das? Für c# habe ich nur code gefunden, der 
Nummern in den Text einfügt. Das macht die Handhabung etwas umständlich, 
da nach jedem einfügen von Zeilen die Nummerierung neu geschrieben 
werden muss.

Ich habe ja jetzt über die c#-form Zugriff auf den makefile und damit 
auf den winAVR-compiler. Theoretisch müsste das ja auch mit anderen 
Compilern - die mittels makefile arbeiten - funktionieren. Interessant 
wären insbesondere compiler für arm und für esp32. Bekäme man Zugriff 
auf die mit winAVR?

grundschüler schrieb:
> Problem Zeilennummerierung

Da musst du wohl das Text-Steuerelement anpassen oder ein eigenes 
implementieren. Musst du sowieso, für Syntax Highlighting & Co.

grundschüler schrieb:
> compiler für arm und für esp32. Bekäme man Zugriff auf die mit winAVR?

WinAVR ist, Überraschung, für AVR und nicht für ARM oder Xtensa. Man 
muss dafür natürlich die entsprechenden Compiler installieren.

Programmierer schrieb:
> WinAVR ist, Überraschung, für AVR und nicht für ARM oder Xtensa. Man
> muss dafür natürlich die entsprechenden Compiler installieren.

Schon klar.

Aber Konzept makefile: Da stehen viele Befehle drin, die abgearbeitet 
werden. Es wird von c in Maschinensprache übersetzt und dann das ganze 
per linker in einen hex.file zusammengefasst.

Es gibt ja verschiedene toolchains - Werkzeuge die nacheinander 
ausgeführt werden. Meinem programm ist es relativ egal, ob es einen 
makefile für winAVR oder ARM-eclipse aufruft. Die Frage ist, kann man 
mit winAVR toolchains für andere mcus abarbeiten. Wenn das mit winAVR 
funktionieren würde, ginge es auch mit meinem Programm.

Besonders interessieren würden mich Arduino-Bibliotheken. Werden die 
auch über makefiles abgearbeitet?

grundschüler schrieb:
> Aber Konzept makefile: Da stehen viele Befehle drin, die abgearbeitet
> werden. Es wird von c in Maschinensprache übersetzt und dann das ganze
> per linker in einen hex.file zusammengefasst.

das makefile definiert hauptsächlich Abhängigkeiten, da werden keine 
Befehle abgearbeitet. Es wird von make benutzt und das ruft dann 
x-beliebige Programme auf. Irgendwie scheint dir das Konzept nicht klar 
zu sein.

Und andere Plattformen wie das ESP IDF arbeiten übergeordnet noch mit 
cmake, das generiert erstmal das makefile. Was auch schon wieder 
veraltet ist weil es z.B. Ninja gibt was wieder eine andere make-Syntax 
hat. Auch das wird von cmake generiert.

Und Arduino ist durch vielen verschiedenen Plattformen die mittlerweile 
unterstützt werden da absolut nicht einheitlich. Es gibt auch welche die 
Mbed als Unterbau haben und das nutzt da auch cmake und Ninja.

Das makefile Gebastel ist eine ziemliche Sackgasse.

grundschüler schrieb:
> Meinem programm ist es relativ egal, ob es einen
> makefile für winAVR oder ARM-eclipse aufruft.

"Makefile für ARM-eclipse" macht keinen Sinn. Es ist wenn schon ein 
Makefile, welches den GNU-ARM-Embedded-Compiler aufruft, welcher rein 
zufällig der gleiche Compiler ist, den die ARM-Eclipse-Varianten auch 
nutzen.

grundschüler schrieb:
> Die Frage ist, kann man
> mit winAVR toolchains für andere mcus abarbeiten.

Wie kann ein Compiler eine andere Toolchain "abarbeiten"? Du willst 
avr-gcc aufrufen und der... ruft dem arm-none-eabi-gcc auf?! Das macht 
keinen Sinn und geht nicht. Ruf doch einfach ein Makefile auf, welches 
den arm-none-eabi-gcc aufruft. Das hat dann nichts mehr mit WinAVR zu 
tun.

Oder besteht das Problem darin, dass du das Make aus WinAVR voraussetzt? 
Schreibe deine IDE so, dass sie mit verschiedenen Makes klarkommt, z.B. 
eben dem aus WinAVR, dem von MinGW, dem von Cygwin, oder dem von Eclipse 
Embedded CDT verwendeten Make-Paket ( 
https://xpack.github.io/windows-build-tools/install/ ), welches im 
Übrigen auch super als kleines Stand-Alone-Make  für Windows benutzt 
werden kann.

grundschüler schrieb:
> Besonders interessieren würden mich Arduino-Bibliotheken. Werden die
> auch über makefiles abgearbeitet?

Man kann die Libraries per Makefile compilieren, ja. Man kann auch im 
eigenen Makefile die arduino-cli aufrufen.

Programmierer schrieb:
> Ruf doch einfach ein Makefile auf, welches
> den arm-none-eabi-gcc aufruft. Das hat dann nichts mehr mit WinAVR zu
> tun.

Danke - genau so war das gemeint.

Das Projekt schreitet voran. Was ich habe ist eine ausbaufähige 
Oberfläche zur Verwaltung von Projekten und ein lauffähiges Konzept zur 
Autovervollständigung von code per timer. Problem ist der Texteditor. 
Anspruch ist so wie notepad++. npp beruht auf scite.

Ich würde also gern auf scite aufbauen.

https://scintilla.org/SciTEExtension.html

D.h.  Entweder Windows-form und timer in scite integrieren oder scite 
über meine c#-form auswerten und steuern. Geht das?

entweder:geht
oder:geht

aber was willst du?
und was hast du bisher probiert?
und was klappt nichtẞ

grundschüler schrieb:
> Problem ist der Texteditor.
Welches Problem?
> Anspruch ist so wie notepad++. npp beruht auf scite.
Welcher Anspruch?
> Ich würde also gern auf scite aufbauen.
Warum?


Sag doch einfach was du willst - und was nicht geht...

Norbert schrieb:
> Sag doch einfach was du willst - und was nicht geht...

ich will in meiner c#-form die richtextbox durch die scite-textbox 
ersetzen damit ich so Sachen wie Zeilennummerierung und 
Sytaxhighlighting nicht selbst schreiben muss.

Ich weiß wie ms-office-interop-Funktionen funktionieren. Mit der winAPI 
habe ich noch nie gearbeitet. Ich hoffe, dass das ähnlich funktioniert. 
Was nicht geht weiß ich noch nicht weil ich es noch nicht ausprobiert 
habe.

Hilfe brauche ich zur Zeit nur insoweit, als mir jemand sagen müsste, 
falls ich mich mit scite auf einem kompletten Holzweg befinde.

grundschüler schrieb:
> Hilfe brauche ich zur Zeit nur insoweit, als mir jemand sagen müsste,
> falls ich mich mit scite auf einem kompletten Holzweg befinde.

Schau dir doch mal Autoit an. Die verwenden auch scite...

Ich hänge ziemlich fest:

1

      public static void xMain(string[] args)

2

        {

3

 //    uint SDI = ::RegisterWindowMessage("SciTEDirectorInterface");

4

uint SDI = RegisterWindowMessage("SciTEDirectorInterface");

5

6

7

            HWND w = ::GetWindow(::GetDesktopWindow(), GW_CHILD);

8

9

            while (w)

10

            {

11

                DWORD res = 0;

12

            // Need time out to avoid hung applications

13

            ::SendMessageTimeout(w, SDI, 0, 0,

14

                SMTO_NORMAL, 1000, &res);

15

                if (res == static_cast<DWORD>(SDI))

16

                {

17

                // Replied with same SDI code so should

18

                // understand SDI's version of WM_COPYDATA

19

                ::SendMessage(w, WM_COPYDATA,

20

                    (UINT)m_hWnd, (long)&cds);

21

                }

22

                w = ::GetWindow(w, GW_HWNDNEXT);

23

24

            }

Diese scite-Funktion müsste entweder von cpp nach c++ übersetzt werden 
oder es bräuchte eine windowsform mit timer in cpp. Beides habe ich 
vergeblich versucht.


HWND w = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
müsste doch in c# übersetzbar sein. Ich steh da etwas auf dem Schlauch 
und finde auch keine brauchbaren code c#/winApi im Netz.

cpp nach c++
muss heißen
cpp nach c#

Was ein Aufriss, nur für ein bissi AVR-Programmierung?

Da ich privat kein Windows nutze, kommt Atmel Studio für mich nicht in 
Frage. Ich arbeite daher mit VS Code und einem hanfgedengelten Makefile, 
der, aus VS Code heraus angestoßen, kompiliert und im Erfolgfalle per 
AVRdude den Kram auch gleich ins Flash wirft. Funktioniert 1a.

Zugegeben, es hat keinen Debugger, allerdings sind die 
Debuggingmöglichkeiten auf einem per AVR-ISP Mk II angeschlossenen AVR 
von Haus aus sehr dünn gesät. ;-) Was die Hardware nicht kann, braucht 
die IDE nicht zu unterstützen.

Nachdenklicher schrieb:
> hanfgedengelten Makefile
Na dann kann man ja seeeehr entspannt damit arbeiten ;-)

Max M. schrieb:
> Na dann kann man ja seeeehr entspannt damit arbeiten ;-)

Danke für die Erheiterung angesichts meines Fipptehlers. ;-)
Ich glaube, die maßgebliche Substanz bei der Erstellung des Makefiles 
war allerdings Dr. Pepper. Handprodukte kann ich jedenfalls 
ausschließen. :-D

Aber Spaß beiseite, damit arbeitet es sich wirklich sehr entspannt. Ja, 
die Erarbeitung einer gescheiten Vorlage hat etwas Zeit gekostet (nicht 
ansatzweise so viel Zeit wie die Erstellung einer eigenen IDE), aber 
letztlich brauche ich jetzt nur noch die Liste der .c-Dateien anpassen, 
und in der Konfiguration auswählen, ob ich das Compilat per ISP (für 
eigene Schaltungen) oder Arduino-Bootloader (wenn ich nur schnell was 
testen will und die Hardware auf Arduinobasis ist) programmieren möchte, 
oder ob ich einfach nur ein hex-file erzeugen möchte, für die Projekte, 
bei denen ich über einen eigenen Bootloader via UART arbeite.
Und wenn man sich überwiegend im Linux-Umfeld bewegt, ist etwas Wissen 
über Makefiles ja auch nicht unbedingt hinderlich.

grundschüler schrieb:

> Ich weiß wie ms-office-interop-Funktionen funktionieren. Mit der winAPI
> habe ich noch nie gearbeitet. Ich hoffe, dass das ähnlich funktioniert.

Tut es nicht. Völlig anderes Konzept. Aber auch das "WinAPI" selber hat 
schon eine ziemliche Spanne bezüglich der Konzepte. Es ist schon ein 
erheblicher Unterschied, ob du direkt auf "user" und "gdi" aufsetzt oder 
auf "common controls".

c-hater schrieb:

> Tut es nicht. Völlig anderes Konzept. Aber auch das "WinAPI" selber hat
> schon eine ziemliche Spanne bezüglich der Konzepte. Es ist schon ein
> erheblicher Unterschied, ob du direkt auf "user" und "gdi" aufsetzt oder
> auf "common controls".

Ergänzend: wenn du was in C# programieren willst, bist du mit mit dem 
WinAPI allerdings grundsätzlich ziemlich auf dem Holzweg. Da solltest du 
besser von halbwegs passenden .net-Komponenten erben.

c-hater schrieb:
> c#-Holzweg

Es ist - für mich - mühselig. Aber es geht:
https://code-bude.net/2014/08/27/beliebige-programme-per-csharp-manipulieren/

c-hater schrieb:
> c#-Holzweg

winAPI kostet zu viel Zeit. Habe jetzt von scite auf ms-word umgestellt. 
Damit geht im Prinzip alles und in word sind zusätzlich die vb-macros 
verfügbar.

grundschüler schrieb:
> winAPI kostet zu viel Zeit. Habe jetzt von scite auf ms-word umgestellt.

Und geht das mit
Linenumbering
Syntaxhighlight
Codecompletion
etc?

Und ms-word ist natürlich eine Hürde fürs weitergeben - hat ja nicht 
jeder, halte das für einen schnellen "Erfolg" - aber letztendlich 
Sackgasse

Grundschullehrer schrieb:
> Linenumbering

Grundschullehrer schrieb:
> Und geht das mit
> Linenumbering
> Syntaxhighlight
> Codecompletion
> etc?

- Linenumbering ist in word standardmäßig drin
- Syntaxhighlight geht per einfachem vba-macro
- Codecompletion geht über c#-timer, der die word-Anwendung auf neue 
Eingaben überprüft.

Mit vba-word kann man fast alles machen. Nervig ist nur der Wechsel von 
c auf vb bei den word-macros.


> Und ms-word ist natürlich eine Hürde fürs weitergeben - hat ja nicht
 jeder

Das stimmt. Wenn es aber tatsächlich so gut werden sollte dass man es 
weitergeben kann, stünde sicher noch ein Wechsel zu scite/winAPI an. Ich 
denke, c# und winAPI müsste grundsätzlich hinzubekommen sein. Mir dauert 
das aber momentan zu lange - ich will die ide schnell praktisch nutzen.

Zuerst dachte ich, der Thread sei aus den 90ern und jetzt ging mir noch 
das Popcorn aus. Ganz groszes Kino hier!!

LL(1) NP parser schrieb:
> Ganz groszes Kino

Wieso? MS Word als Editor ist doch mal echt innovativ.
Code 'Vervollständigung' mittels Wörterbuch und Thesaurus, kennt zwar 
keine Computersprachen und keine Einrückung nach Syntax, aber dafür kann 
ich Code mit verschiedenen Größen und Schriftarten formatieren.
Farblich muss ich das dann natürlich selber Wort für Wort einfärben.

Schade das es diese extremst nervige Büroklammer mit Logorrhö nicht mehr 
in ms Word gibt.
Da wirft man doch gleich seinen Notepad++ weg, wenn man das auch viel 
schlechter UND viel teurer mit ms Word machen kann.

Können wir den TO nicht irgendwie mit Josef zuammenbringen?
Die beiden zusammen könnten wirklich die Welt verändern 😂