winAvr soll ja ein einfaches Textprogramm sein, welches über Kommandozeilen abgearbeitet wird. > "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 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 --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 -------- Erster Schritt Compiling: C:\_zuc_workspace\20211012_wind>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 main.c:14: fatal error: opening dependency file .dep/main.o.d: No such file or directory compilation terminated. Scheitert an .dep/main.o.d. Wie erstellt man .dep/main.o.d? Wo kann man dazu etwas nachlesen? Ich hätte gerne eine mit c# erstellte eigene ide
grundschüler schrieb: > winAvr soll ja ein einfaches Textprogramm sein, welches über > Kommandozeilen abgearbeitet wird. Beides falsch. > Wo kann man dazu etwas nachlesen? Im makefile. WinAVR kommt mit einem Steinzeitcompiler, der braucht Hilfestellung bei der Dependency-Ermittlung. Oliver
:
Bearbeitet durch User
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: > gar nicht so schwierig. Man muss nur den Befehl "make" eingeben - dann > wird der makefile abgearbeitet. So isses. Seit seiner Erfindung vor ca. 45 Jahren hat sich daran kaum was geändert. Oliver
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. Ich denke, es geht deutlich besser. Gut, einiges davon ist nicht einmal eine IDE. Ich möchte nicht wissen, wie viele Millionen Zeilen Code so ein Eclipse hat. Viel Erfolg auf jeden Fall...
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.
Eigene IDE? Erstens gibt es sehr gute Betriebssysteme unter denen C# völlig unbekannt ist - was auch ganz gut so ist! Und Zweitens gibt es VIM und seine forks - wer braucht da noch eine eigene IDE? LOL
:
Bearbeitet durch User
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...
Walter K. schrieb: > Und Zweitens gibt es VIM und seine forks - wer braucht da noch eine > eigene IDE? In dem Fall allerdings lautet die Antwort: genau deshalb ;) Oliver
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.
Beitrag #6952997 wurde von einem Moderator gelöscht.
Max M. schrieb: > 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. Hat da jemand "Elon Musk" geflüstert? ;-)
c-hater schrieb: > 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... Alle BSD‘s, wie z.B. FreeBSD, OpenBSD, NetBSD usw.
grundschüler schrieb: > Ich hätte gerne eine mit c# erstellte eigene ide grundschüler schrieb: > Es kommt immer auf das Maß der Faulheit an - ich bin besonders faul. Ja, das passt super. Respekt schrieb: > Respekt. Du wirst deinen Weg machen. Wohin der führt ist allerdings > unklar. Mir schon: in die Versenkung. Max M. schrieb: > 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. Das nennt sich schlicht Dunning Kruger Effekt
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.
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.
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.
Es gibt ein NuGet-Paket für die Benutzung von Scintilla unter .NET. (Scintilla ist das Texteditor-Control, Scite ist ein Texteditor, der Scintilla verwendet) Vielleicht ist das ja hilfreich... BTW: Eine Google-Suche nach "scintilla c#" ergab 3k+ Treffer. merciless
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.
Der eigentliche Holzweg ist, das Ganze mit einem unmodifiziertem Stand-Alone-Editor (egal ob Notepad, scite oder ...schauder... MS-Word) zu machen, den die sog. "IDE" dann per (was auch immer) fernsteuert. Bau den Code-Editor lieber in deine IDE ein. "Integrier" ihn, dafür steht das "I" in "IDE" :) Das bedeutet nicht, dass du den Texteditor incl. aller Syntax-Highlight-, Auto-Complete- usw. Funktionen selber programmieren musst. Passendes Control nehmen, in deine GUI ziehen, "fertig" :). Scintilla wurde genannt, willkürlich examples gegooglet: https://csharp.hotexamples.com/examples/ScintillaNET/Scintilla/-/php-scintilla-class-examples.html
Ach ich finde die Lösung mit MS Word .... ... spannend und würde gerne wissen, wie es weitergeht ;) merciless
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: > Und ms-word ist natürlich eine Hürde fürs weitergeben - hat ja nicht > jeder, Warum nicht gleich als Excel Macro. Dann kann endlich jeder BWLer compilieren. Wenn, dann konsequent.
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 😂
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.