Der Workshop richtet sich an alle Gitarristen und Gitarristinnen, die an akustischem Blues interessiert sind. Der Schwerpunkt liegt bei Fingerpicking Blues und dem Zusammenspiel. Wir wollen sowohl an Grooves für Begleitungen als auch an leichtem Solospiel mit Wechselbässen und darüber liegenden Melodien arbeiten. Neben der Standardstimmung wird es auch Einblicke in die offenen Stimmungen geben. Auch Grundlagen des Bottleneckspiels werden vermittelt. Grundlagen: Du solltest die Standardakkorde kennen und greifen können. Der Kurs findet statt im schön über der Stadt Bamberg gelegenen Montanahaus der Dillinger Franziskanerinnen am Friedrichsbrunnen 7a, 96049 Bamberg.

Blues Picking Workshop mit Rainer Brunn

Es gibt noch einige wenige freie Plätze für Rainer Brunns Blues Picking Herbstcamp in Bamberg!

Der Workshop richtet sich an alle Gitarristen und Gitarristinnen, die an akustischem
Blues interessiert sind. Der Schwerpunkt liegt bei Fingerpicking Blues und dem Zusammenspiel.
Wir wollen sowohl an Grooves für Begleitungen als auch an leichtem Solospiel mit
Wechselbässen und darüber liegenden Melodien arbeiten.
Neben der Standardstimmung wird es auch Einblicke in die offenen Stimmungen geben.
Auch Grundlagen des Bottleneckspiels werden vermittelt.

Grundlagen: Du solltest die Standardakkorde kennen und greifen können.
Der Kurs findet statt im schön über der Stadt Bamberg gelegenen Montanahaus der
Dillinger Franziskanerinnen am Friedrichsbrunnen 7a, 96049 Bamberg.

Hier geht’s zum Anmeldeformular:
https://mbergmann-sh.de/dl/files/Anmeldeformular.pdf

5-String Banjo Tuning Tipps

Saitenwechsel und Stimmen

Beim Banjo ist die Bridge, anders als bei der Gitarre, nicht fixiert. Dieser Umstand verursacht einige Besonderheiten beim Saitenwechsel – zum Einen muss die korrekte Position der Bridge gegeben sein, damit dein Banjo bundrein ist und zum Anderen soll sich die Bridge-Position beim Saitenwechsel nicht verschieben können. Aus diesem Grund empfiehlt es sich, die Saiten Eine nach der Anderen zu wechseln.

Neue Saiten aufziehen

Banjo-Tuning Der Saitenwechsel

Damit sich die Bridge bei einem bereits gut eingestellten Banjo nicht verschieben kann, solltest du die Saiten nacheinander wechseln. Am besten beginnst du mit der 5. oberen G-Saite und wechselst so Saite für Saite nacheinander aus. Eine frisch aufgezogene Saite solltest du nach dem Aufziehen noch nicht stimmen, bis alle Saiten gewechselt sind und die Bridge sich in ihrer korrekten Position befindet.

  • Schneide die Saite, die du ersetzen willst, nicht einfach irgendwo durch. Du benötigst ihre Länge, um die Länge der neuen Saite zu messen. Lockere nur diese Saite so weit, bis sie sich vom Stimmwirbel und Tailpiece (Saitenhalter) lösen lässt.
  • Messe die Länge der neuen Saite anhand der eben Entfernten und ziehe sie auf.
  • Achte darauf, dass die Saite in die richtige Richtung (siehe Abbildung oben) gewickelt wird.
  • Beim Ersetzen der 5. Saite verliere nicht die Führung (Spike), in der sich diese Saite kurz vor dem Stimmwirbel bewegt. Achte auf die Wickelrichtung. Wenn du die Saite in die falsche Richtung gewickelt hast, kann sie durch die Spannung und Vibration während des Spielens nach gewisser Zeit den Spike, über welchen sie läuft, beschädigen.

Die Grundstimmung

Banjo-Tuning: Die Grundstimmung

Das 5 String Banjo wird meistens auf eine offene G-Stimmung – g D G B D – gestimmt. Prüfe nach einem Saitenwechsel unbedingt vor dem Stimmen die Position der Bridge!

Sobald du alle Saiten nacheinander ausgetauscht hast, stimme jetzt eine Saite nach der anderen auf 3 Noten niedriger, als sie sein sollten, dann um 2 Noten, dann um 1 Note niedriger und am Schluss alle Saiten auf die richtige Note. Nehmen wir als Beispiel die Saite G – zuerst stimmst du sie auf Note E, dann auf F, dann auf F# und schließlich auf die richtige Note G.

Überprüfe zum Schluss die Oktavreinheit deines Stimmversuchs per Flageolett im 12. Bund.

Bridge-Position bestimmen

Banjo-Tuning: Bestimmen der Bridge-Position

Klingt dein Banjo nicht mehr bundrein, dann musst du die Position der Bridge korrigieren! Die Position der Brücke wird auf diese Weise gemessen:

Vom Sattel im 1. Bund bis zum 12. Bundstäbchen im 12. Bund, dann vom gleichen 12. Bundstäbchen bis zur Bridge. Diese Abstände müssen gleich sein! Die Bridge ist bei den meisten 5-String Banjos 8 cm breit. Wenn du den Abstand nur zur Mitte der Bridge hin misst, dann kann es passieren, dass sie schief auf dem Head steht – deshalb messe im Abstand von 12 Bundstäbchen zu den beiden Rändern der Bridge.

Um genau zu überprüfen, ob die Bridge in der richtigen Position steht, musst du alle Saiten stimmen und im 12. Bund die Noten überprüfen (Stimmgerät!). Die dünne erste Saite D im 12. Bund spielt Note D, Saite B spielt Note B und dicke D Saite spielt Note D. Hast du diese Noten im 12. Bund, hast du die richtige Brückenposition gefunden. Wenn die Noten nicht stimmen, musst du die Bridge zu oder von Tailpiece verschieben. Bei zu tiefen Tönen, also vor dem richtigen Ton auf dem Tuner, solltest du die Brücke vorsichtig in Richtung Tailpiece verschieben. Sind die Töne zu hoch, also hinter dem richtigen Ton im Tuner, solltest du die Brücke leicht zur Mitte des Banjos verschieben.


Du findest dieses Tutorial hilfreich? Dann freue ich mich über eine kleine finanzielle Anerkennung – herzlichen Dank! 🙂

[weitere Kompakt-Tutorials]

Soleier nach Micha B.

Soleier sind die schmackhafteste Art, um Eier zu konservieren. Sie fehlten früher in keinem „Hungerturm“ in jeder noch so kleinen Dorfkneipe.

Zutaten (für 3 Gläser à 1,0 l):

  • 15 frische Eier (Kl. M)
  • 3 Zwiebeln
  • 80 g Zucker
  • 120 g Meersalz
  • 2 EL helle Senfsaat
  • 1 EL Kümmel
  • 2 EL schwarze Pfefferkörner
  • 2 rote Chilischoten
  • 6 Zehen Knoblauch
  • 6 Wacholderbeeren
  • 4 Pimentkörner
  • 3 Lorbeerblätter
  • 1 EL provenzialische Kräuter
  • 400 ml Rote-Bete-Saft
  • 300 ml Apfelessig
  • 1 Bund Dill
  • 1 Bund glatte Petersilie
  • Schale von 1 unbehandelten Zitrone

Zubereitung: Eier in 10 bis 12 Minuten hart kochen, mit kaltem Wasser abspülen und pellen. Zwiebeln und Knoblauch ungeschält halbieren. Die Schnittflächen in einer Pfanne ohne Fett zusammen mit dem Knoblauch goldbraun rösten.

In einem Topf 2,3 Liter Wasser mit Zwiebeln, Knoblauch, Zucker, Salz, Senfsaat, Kümmel, Pfefferkörnern, Chilischote, Wacholderbeeren, Piment, Lorbeerblättern, Rote-Bete-Saft und Essig aufkochen. Sobald sich Zucker und Salz aufgelöst haben, den Sud bei schwacher Hitze etwa 5 Minuten köcheln lassen. Vom Herd ziehen und abkühlen lassen.

Dill, Petersilie, Zitronenschale und Eier auf die gut verschließbares Gläser verteilen. Mit dem abgekühlten Sud übergießen und mindestens 24 Stunden ziehen lassen. Die Soleier sind eine Woche haltbar, im Kühlschrank auch locker bis zu 2 Wochen.

Tipp – so werden Soleier gegessen: Ei halbieren, das Eigelb herausheben. In jede Eiweißhälfte Salz, Pfeffer, Essig, Öl und Senf geben. Das Eigelb hineinsetzen und genießen.

„Russische Eier“ – die Edelvariante: Eigelb aus den Eihälften herausheben. Eigelbe mit Salz, Pfeffer, Essig, Öl und Worcestershiresauce würzen und mit dem Schneebesen oder Handrührgerät cremig rühren. Die Eiweißhälften mit der Eigelbmasse füllen, einen kleinen Löffel falschen Kaviar draufsetzen und mit frischer Kresse und Senfsprossen bestreuen.


Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Portugiesische Fischsuppe mit Muscheln, Kartoffeln und Chorizo

Portugiesische Fischsuppe mit Chorizo und Kartoffeln

 

Diese bodenständige Fischsuppe ist etwas für Feinschmecker mit Hang zum Rustikalen. Traditionell wird sie mit Bacalao – das ist getrockneter Kabeljau (Stockfisch) zubereitet, schmeckt aber auch mit frischem Kabeljau und weiteren Fischen ganz hervorragend.

Zutaten:

  • 2 EL Olivenöl (natives, extra vergine)
  • 2 Lorbeerblätter
  • 6 Knoblauchzehen, fein gehackt
  • 2 große Zwiebeln (ca. 400 g), gewürfelt
  • 1 grüne Paprika (ca. 170 g), gewürfelt
  • ¼ TL Piment (gemahlen) – das verleiht eine warme, würzige Note
  • 900 g festkochende Kartoffeln, geschält und in 0,7 cm dicke Scheiben geschnitten
  • 1 Glas trockener Weißwein
  • 1 Liter Fisch- oder Hühnerbrühe, gekocht aus dem Einweichwasser des Bacalao und etwas Weißwein (alternativ: Gemüsebrühe)
  • 2 Tassen gehackte Tomaten aus der Dose (inkl. Saft)
  • 170 g Chorizo, in feine Scheiben geschnitten
  • 900 g Bacalao oder Weißfischfilet (z. B. Kabeljau, Seehecht oder Rotbarsch), entgrätet und in Stücke geschnitten
  • 6 – 8 Garnelen
  • 6 – 8 Miesmuscheln
  • 3 Zweige frischer Koriander, grob gehackt
  • Salz & frisch gemahlener schwarzer Pfeffer nach Geschmack
  • 2 EL frische Petersilie, grob gehackt
  • 1 frische, milde Chili, fein gehackt
  • Für die Beilage: 8 Scheiben Weißbrot, 1 TL provenzalische Kräuter und 2 Zehen fein gehackter Knoblauch

Zubereitung:

  1. Wässere den Bacalao über Nacht in 1 Liter gesalzenem Wasser und lasse ihn dann abtropfen (Wasser auffangen!)
  2. In einem großen Suppentopf das Olivenöl erhitzen. Gib die Lorbeerblätter, Knoblauch, Zwiebeln, Chili, Paprika und Piment hinzu. Unter ständigem Rühren bei mittlerer Hitze ca. 5 Minuten glasig dünsten, bis die Mischung duftet und das Gemüse weich geworden ist. Dieser Schritt bildet das Aromafundament der Suppe und sorgt für einen vollmundigen Geschmack.
  3. Die Kartoffelscheiben unterrühren und alles mit der Brühe und den gehackten Tomaten samt Saft ablöschen. Gut umrühren, aufkochen lassen und dann die Hitze auf mittlere Stufe reduzieren. Die Suppe nun 15 Minuten leicht köcheln lassen, bis die Kartoffeln fast gar sind – sie sollten weich, aber noch nicht zerfallen sein.
  4. Zerdrücke ein Drittel der Kartoffeln – das macht die Suppe sämig. Verrühre alles gut miteinander.
  5. Nun die Chorizo-Scheiben in die Suppe geben. Diese geben beim Garen ihre rauchige Würze in die Brühe ab. Anschließend die Fischstücke, die Garnelen und die Muscheln vorsichtig obenauf legen, nicht umrühren, sondern nur auf der Oberfläche leicht andrücken. Den Topf mit einem Deckel verschließen und die Suppe bei niedriger Hitze weitere 8 bis 10 Minuten ziehen lassen, bis der Fisch zart und durchgegart ist und die Muscheln sich geöffnet haben.
  6. Die Lorbeerblätter entfernen. Den frisch gehackten Koriander einrühren und die Suppe mit Salz und Pfeffer abschmecken. Die Aromen sollten nun wunderbar miteinander verschmolzen sein – würzig, herzhaft und aromatisch.
  7. In der Zwischenzeit Weißbrotscheiben in einer Pfanne mit etwas Olivenöl, provenzalischen Kräutern und gehacktem Knoblauch anrösten.
  8. In tiefen Tellern oder rustikalen Schüsseln anrichten und mit Petersilie bestreuen. Sofort heiß servieren – idealerweise mit dem geröstetem Knoblauchbrot.

Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Bärlauch-Pesto mit Pecorino und Walnüssen

Bärlauch-Pesto mit Pecorino und Walnüssen Rezept auf www.mbergmann-sh.de

Bärlauch hat von April bis Mai Saison – leider viel zu kurz für dieses schmackhafte und gesunde Würzkraut. Wenn man ihn mag, dann hilft nur Eins: Haltbar machen!

Eine gute und leicht umsetzbare Möglichkeit ist es, den Bärlauch mit Käse, Olivenöl und ein paar Nüssen zu einem Pesto zu verarbeiten. Für mein Rezept brauchst du

  • 350 g frischen Bärlauch
  • 2 Zehen Knoblauch
  • 150 g ungesalzene Pinienkerne
  • 150 g Walnüsse
  • 150 g Pecorino (oder einen anderen würzigen Hartkäse)
  • den Saft einer halben Limette
  • eine halbe frische, rote Chili
  • 8 EL gutes Olivenöl
  • Meersalz und schwarzen Pfeffer aus der Mühle
  • 1 EL Hefeflocken

Das reicht für ca. 850 g fertige Pesto, respektive 3 bis 4 Gläser. Für die Zubereitung verwendest du am Besten ein ausreichend großes, schmales und hohes Gefäß und einen Pürierstab.

Zubereitung:

  1. Gib die Pinienkerne, Walnüsse und den Limettensaft zusammen mit einer Handvoll Bärlauch, der Chili, einem EL Olivenöl und den Knoblauchzehen in das Gefäß. Würze alles mit 1 TL Meersalz und einer kräftigen Prise Pfeffer.
  2. Püriere alles, gib dabei nach und nach den restlichen Bärlauch und löffelweise Olivenöl bei.
  3. Reibe nun den Pecorino in das Gefäß, gib die Hefeflocken bei und püriere die Masse nochmals.
  4. Schmecke den Pesto ggf. nochmal mit Salz und Pfeffer ab.
  5. Fülle den Pesto in vorbereitete Twist-Off-Gläser, bedecke den Pesto mit Olivenöl und verschließe die Gläser.
  6. Kühl und dunkel lagern, damit die Farbe nicht verloren geht!

Der Pesto hält sich bei kühler Lagerung wochenlang.

Tipp: Hausgemachter Pesto ist nicht nur ein gesunder Brotaufstrich, sondern verfeinert auch viele italienisch anmutende Gerichte und Saucen. Probiere ihn mal auf frisch gekochten Spaghetti – ist ein Träumchen!


Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Crêpes mit gebratenen Austernseitlingen und Bärlauch

Crêpes müssen nicht immer nur süß daherkommen – auch mit würzigen Füllungen schmecken sie ganz hervorragend und werden so zur leckeren Hauptmahlzeit!

Um meine Crêpes mit Pilzen und Bärlauch nachzukochen, brauchst du

Für den Crêpes-Teig:

160 Weizenmehl (Type 405)
15 g Roggenmehl (Typ 605)
5 g Backmalz
1 Prise Zucker
je 1 gute Prise Meersalz und Pfeffer
Eier (Gr. M)
250 ml Milch
25 g geschmolzene Butter

 

Für die Füllung:

500 g Austernseitlinge, in Streifen geschnitten
1 kleine Zwiebel, gehackt
1 Bund Bärlauch, fein gehackt
1 kleiner Bund Thymian, fein gehackt
1 EL Limettensaft
1 EL Olivenöl
1 EL Creme Fraiche
1 TL Hefeflocken
Salz, Pfeffer aus der Mühle

Zubereitung:

  1. Für den Teig Mehl mit Zucker, Salz, Pfeffer und Backmalz vermischen. Eier und Milch hinzufügen und mit einem Schneebesen oder dem Handrührgerät zu einem glatten Teig verrühren.
  2. Die geschmolzene, nicht zu heiße Butter in einem dünnen Strahl einlaufen lassen und dabei unterrühren. Der Teig muss relativ dünnflüssig sein, damit er auf dem Crêpes-Maker oder in der Crêpes-Pfanne möglichst dünn verstrichen werden kann.
  3. Den Teig mindestens ca. 30 Minuten ruhen lassen!
  4. Für die Füllung 1 EL Olivenöl in einer gusseisernen Pfanne erhitzen, die Pilze und die Zwiebel darin von allen Seiten kurz anbraten.
  5. Bärlauch, Thymian, Limettensaft, Hefeflocken und die Creme Fraiche unterheben, mit Salz und Pfeffer aus der Mühle abschmecken. Die Pfanne anschließend für die weitere Verwendung warm stellen!
  6. Crêpes ausbacken: Gib eine Kelle Teig auf die heiße Crêpe-Platte und verteile ihn mit dem Crêpe-Stempel dünn über die gesamte Platte. Backe den Crêpe für ca. 60 Sekunden und wende ihn dann.
  7. Belege ihn nach weiteren 60 Sekunden mit einem EL der Pilzmischung und falte ihn nach der Methode 6 zu einer Tüte (siehe Faltanleitung!).
  8. Gib den Crêpe auf einen vorgewärmten Teller und dekoriere ihn mit ein Wenig gehacktem Bärlauch.
  9. Wiederhole die Schritte 6 bis 8 für weitere Crêpes.

Tipp: Das Rezept lässt sich saisonal auch prima mit anderen Pilzen, wie z.B. frisch gesammelten Maronen oder Steinpilzen, zubereiten!

Guten Appetit!

Anleitung zum Falten von Crêpes

10 Arten, um Crêpes richtig zu falten www.mbergmann-sh.de


Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Zitronenthymian-Knoblauch-Aufstrich

Dieser vegane Brotaufstrich zieht dir die Schuhe aus!

Zutaten:

200 g Cashew-Kerne
4 getrocknete Aprikosen
2 EL getrocknete Cranberries
10 Zehen Soloknoblauch
eine halbe rote Chili, in Ringen
einen kleinen Bund Schnittlauch, in Röllchen
Saft einer halben Limette
1 Bund Zitronenthymian
2 EL Hefeflocken
Meersalz, Pfeffer aus der Mühle

Zubereitung:

  1.  200 Gramm Cashewkerne, 2 EL Cranberries und 4 getrocknete Aprikosen über Nacht in Wasser einweichen.
  2. Knoblauch und Zitronenthymian fein hacken, Limette auspressen.
  3. Wasser abgießen, Aprikosen klein schneiden und alles zusammen mit 2 EL Hefeflocken, dem Thymian, etwas Salz, Pfeffer und dem Limettensaft in einen Mixer geben oder die Menge mit einem Pürierstab pürieren, bis eine cremige Konsistenz entsteht.
  4. Den Schnittlauch unterheben.
  5. In vorbereitete Gläser abfüllen und kühl lagern.

Der Aufstrich hält sich für gute zwei Wochen im Kühlschrank.

Tipp: Probiere den Aufstrich auch mal als Topping zu heißen Spaghetti! Dazu die Spaghetti pro Teller mit 1 EL des Aufstrichs vermengen – mehr braucht es nicht für eine schnelle, würzige Nudelmahlzeit!


Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Bulgur-Graupensuppe mit Sojahack

Dieser gehaltvolle Seelenwärmer schmeckt hervorragend, lässt sich gut aus Resten herstellen – und ist vegan. Du brauchst dafür kein Salz zu verwenden – Hefeflocken verleihen dem Süppchen eine kräftige Würze.

Zutaten:

2 Liter Wasser
1 Bund Suppengrün, fein gewürfelt
1 rote Spitzpaprika, in Streifen
eine halbe frische Chili, in Ringen
1 große Zwiebel, gewürfelt
4 Zehen Knoblauch, in Scheibchen
je eine kleine Tasse Bulgur, Perlgraupen und Sojahack
1 Lorbeerblatt
1 TL Ras-el-Hanout
8 Körner schwarzer Pfeffer, ganz
1 Msp. Zimt, gemahlen
1 Prise frisch geriebene Muskatnuss
1 EL Koriandergrün, fein gehackt
einen halben Bund glatte Petersilie, fein gehackt
einen halben Bund Frühlingszwiebeln, in Ringen
anderthalb EL Vegata (oder einer ähnlichen Suppenwürze)
1 gehäufter EL Hefeflocken
1 EL Sesamöl

Zubereitung:

  1. Spüle den Bulgur in einem engmaschigen Sieb unter fließendem Wasser ab.
  2. Brate das Gemüse im Sesamöl leicht an.
  3. Bringe das Wasser mit Vegata,  einem Lorbeerblatt und den Pfefferkörnern in einem großen Topf zum Kochen.
  4. Gib das Sojahack, den Bulgur und die Graupen hinzu und köchele alles bei kleiner Hitze für 25 Minuten. Rühre dabei regelmäßig um!
  5. Nach 10 Minuten gibst du das gebratene Gemüse hinzu und würzt das Süppchen mit Ras-el-Hanout, Zimt und den Hefeflocken.
  6. Schalte den Herd nach dem Ende der Kochzeit ab, entferne das Lorbeerblatt aus der Suppe und lasse sie bei geschlossenem Deckel noch für 10 Minuten nachquellen.
  7. Gib den Muskat hinzu. Abschmecken und ggf. nachwürzen!
  8. Hebe die Frühlingszwiebeln, die gehackte Petersilie und den Koriander unter und serviere das Süppchen heiß.

Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂

[Übersicht]

Amiga Version String für mit SAS/C, VBCC und amiga-gcc compilierte Programme

Amiga Version String Macro www.mbergmann-sh.de

Auf dem Commodore Amiga besitzen gut geschrieben Programme einen Versions-String, der über die Shell mit dem Befehl ‚version <progname> file full‘ abgefragt werden werden kann.

Gerade dann, wenn man als C-Programmierer zu Testzwecken verschiedene C-Compiler verwendet kann es hilfreich sein, ein Template zu schreiben, um einen solchen Versions-String automatisch zu generieren. Man kann ein solches Template z. B. unter ‚S:myHeader.txt‘ ablegen und bei Bedarf einfach in den Texteditor laden.

Um einen Versions-String per Macro mit dem Programmnamen, der Versionsnummer, dem aktuellen Compilerdatum und Informationen zum verwendeten Compiler zu erstellen, geht man so vor:

#define PROGNAME "meinProgramm"
#define VERSIONR "1.0.0"
#define COPYRIGHT "Copyright © 2025 by Micha B."

/* construct version tag */
#if defined(__VBCC__)
 #define PROGDATE __AMIGADATE__
 #define COMPILER "VBCC"
#endif
#if defined(__SASC)
 #define PROGDATE __AMIGADATE__
 #define COMPILER "SAS/C v6.58"
#endif
#if defined(__GNUC__)
 #define PROGDATE __DATE__
 #define COMPILER "GCC"
#endif

/* AmigaOS Version String */
const char *version = "\0$VER: " PROGNAME " " VERSIONR " (" PROGDATE ") - (" COMPILER ") - " COPYRIGHT "\n";

Warum der Aufwand?

Natürlich könnte man den Versions-String auch einfach so schreiben:

const char *version ="\o$VER: meinProgramm ((01. April 2025)) - (SAS/C) - Copyright by IchSelbst\n";

Man müsste dann halt den String jedesmal verändern wenn die Programmversion wechselt oder ein anderer C-Compiler benutzt wird. Da ist es schon komfortabler, wenn man sich ein entsprechenes Makro angelegt hat.

Ich selbst verwende bei der Programmentwicklung grundsätzlich Templates, da mir das viel Arbeit für Kommentare usw. erspart. Für meine mit dem ReBuild GUI Designer entworfenen Projekte sieht mein Standard-Template so aus:

/*********************************************
 * Project:  ReBuild F.A.Q                   *
 * Purpose:  show some ReAction GUI features *
 * File:     meinprogramm.c                  *
 * Version:  1.0 RELEASE                     *
 * Author:   Michael Bergmann                *
 * Date:     2025/04/04                      *
 *                                           *
 * GUI made with ReBuild v1.3 beta           *
 * Tested Compilers:                         *
 *           SAS/C v6.58                     *
 *           VBCC v0.91 pre                  *
 *           amiga-gcc v6.5                  *
 * HINT: Might be linked against             *
 *       amiga.lib and reaction.lib!         *
 *********************************************
 */
/* --- Put INCLUDE-Files HERE: --- *

 
#define myDebug TRUE  /* Debugging Texts TRUE or FALSE */
#ifdef myDebug
  #include <stdio.h>  /* used for puts(), printf() */
  char *str_greet = "Hello Stranger!\n We're ready to DEBUG now!\n\n";
  char *str_bye = "\n\nAll Done!\nThis Demo quits now.\nHope you liked it?";
#endif

/* construct version tag */
#define PROGNAME "meinProgramm"
#define VERSIONR "1.0.0"
#define COPYRIGHT "Copyright © 2025 by Micha B."

#if defined(__VBCC__)
  #define PROGDATE __AMIGADATE__
  #define COMPILER "VBCC"
#endif
#if defined(__SASC)
  #define PROGDATE __AMIGADATE__
  #define COMPILER "SAS/C v6.58"
#endif
#if defined(__GNUC__)
  #define PROGDATE __DATE__
  #define COMPILER "GCC"
#endif

/* AmigaOS Version String */
const char *version = "\0$VER: " PROGNAME " " VERSIONR " (" PROGDATE ") - (" COMPILER ") - " COPYRIGHT "\n";

/* Function Proto Types */
int main(void);
void window_main( void );
int setup( void );
void cleanup( void );
void runWindow( Object *window_object, int window_id, struct Menu *menu_strip, struct Gadget *win_gadgets[] );

/* --- Additional global stuff goes HERE: --------------------------------------------------------------- */

/* --- Menu IDs ----------------------------------------------------------------------------------------- */
enum menus
{
  /* Menu "Project"  */
  MN_ITEM1
};

/* --- Requesters ---------------------------------------------------------------------------------------- */
/* 'No OS 3.2' box */
struct EasyStruct warnreq =
{
  sizeof(struct EasyStruct),
  0,
  "Error",
  "Needs AmigaOS 3.2.x\n\nNo Chance to run this program on your machine!",
  "Ok"
};

/* 'requester.class problem' box */
struct EasyStruct noreqclassreq =
{
  sizeof(struct EasyStruct),
  0,
  "Critical Error",
  " requester.class could not be opened.\nThis App refuses to start!",
  "Ok"
};

/* --- Function: setup() --------------------------------------------------------------------------------- */
/* --- Open libs, gadgets, classes and other ressources -------------------------------------------------- */
int setup( void )
{
  if( !(IntuitionBase = (struct IntuitionBase*) OpenLibrary("intuition.library",0L)) ) return 0;
  if( !(GadToolsBase = (struct Library*) OpenLibrary("gadtools.library",0L) ) ) return 0;
  if( !(WindowBase = (struct Library*) OpenLibrary("window.class",0L) ) ) return 0;
  if( !(IconBase = (struct Library*) OpenLibrary("icon.library",0L) ) ) return 0;
  
  /* --- Check for a sufficient OS! --- */
  if( !(LayoutBase = (struct Library*) OpenLibrary("gadgets/layout.gadget",47) ) )
  {
    if (myDebug)
       puts(" FAIL: layout.gadget");
    EasyRequest(NULL, &warnreq, NULL);    
    return 0;
  }
  /* Additional Stuff: Place HERE! */
  
} /* END Function setup() */

/* --- Function: cleanup() -------------------------------------------------------------------------------- */
/* --- Close used ressources and clean up for shutdown ---------------------------------------------------- */
void cleanup( void )
{
   /* Copy content of Function cleanup() HERE: */
} /* END Function cleanup() */
 

/* --- Function: runWindow() ------------------------------------------------------------------------------ */
/* --- IDCMP Event Handling is done here ------------------------------------------------------------------ */
void runWindow( Object *window_object, int window_id, struct Menu *menu_strip, struct Gadget *win_gadgets[] )
{
  struct Window	*main_window = NULL;  
  struct MenuItem *menuitem = NULL;
  LONG myItem = 0;                  /* GT menu identifier     */
  ULONG selected;                   /* used for Content query */
  ULONG status = 0;                 /* used for Status query  */
  ULONG req_result = 0;
  if ( window_object )
  {
    if ( main_window = (struct Window *) RA_OpenWindow( window_object ))
    {
      WORD Code;
      ULONG wait = 0, signal = 0, result = 0, done = FALSE;
      GetAttr( WINDOW_SigMask, window_object, &signal );
      if ( menu_strip)  SetMenuStrip( main_window, menu_strip );
      
      if(myDebug)
        printf("%s\n", str_greet);
        
      while ( !done)
      {
        wait = Wait( signal | SIGBREAKF_CTRL_C );

        if ( wait & SIGBREAKF_CTRL_C )
          done = TRUE;
        else
          while (( result = RA_HandleInput( window_object, &Code )) != WMHI_LASTMSG)
          {
            switch ( result & WMHI_CLASSMASK )
            {
              /* --- WINDOW -------------------------------------------- */
              case WMHI_CLOSEWINDOW:
                if(myDebug)
                  printf("%s\n", str_bye);
                done = TRUE;
                break;
                
              /* --- MENUS -------------------------------------------- */
              case WMHI_MENUPICK:
                if(myDebug)
                  puts("\nMenu pick!");
                 
                menuitem = ItemAddress(menu_strip, result & WMHI_MENUMASK);
                if(myDebug)
                  printf(" ItemAdress = %ld\n", menuitem); 
                  
                /* Check if menuitem equals to Zero. If Zero, an enforcer hit will occour when */
                /* attempting to examine, so we do not allow switching on menuitem == 0!       */
                if(!(menuitem == 0))
                {
                  /* --- ...get menu entries by using GadTools' GTMENUITEM_USERDATA field macro --- */
                  myItem = ((long)GTMENUITEM_USERDATA(ItemAddress(menu_strip, result & WMHI_MENUMASK)));
                  /* --- Identify selected menu entry */
                  switch(myItem)
                  {
                    case MN_ITEM1:
                      if(myDebug)
                        puts("\n Menu 'Project': <ITEM> was selected.");
                      
                      break;
                  } /* END switch(myItem) */ 
                } /* END if(!(menuitem == 0)) */
                break;  /* END WMHI_MENUPICK */

              /* --- GADGETS ----------------------------------------- */
              case WMHI_GADGETUP:
                switch (result & WMHI_GADGETMASK)
                {
                  /* --- Gadget 1 --- */
                  case 
                    break;          					
          				           
                } /* END switch (result & WMHI_GADGETMASK) */
                break;  /* END case WMHI_GADGETUP */
                
              /* --- ICONIFY ----------------------------------------- */
              case WMHI_ICONIFY:
                if ( RA_Iconify( window_object ) )
                  main_window = NULL;
                break;

              /* --- UNICONIFY --------------------------------------- */
              case WMHI_UNICONIFY:
                main_window = RA_OpenWindow( window_object );
                if ( menu_strip)  SetMenuStrip( main_window, menu_strip );
              break;
            } /* END switch ( result & WMHI_CLASSMASK ) */
          } /* END while (( result = RA_HandleInput( window_object, &Code )) != WMHI_LASTMSG) */
      } /* END while ( !done) */
    } /* END if ( main_window = (struct Window *) RA_OpenWindow( window_object )) */
  } /* END if ( window_object ) */
} /* END Function runWindow() */


/* --- Function: window_main() ----------------------------------- */
/* --- All window-specific setup for main Window is done here. --- */ 
/* ---'runWindow()' is called for message handling afterwards. --- */
void window_main( void )
{
  /* We changed ReBuild's menu struct output in order to obey to GadTools Menu handling! */
  /* Replaced: Last NULL argument by (APTR) <Item identifier>                            */

} /* END Function window_main() */


/* --- Main Function ---------------------------------------------------------------------------------- */
int main(void)
{
  if ( setup() )    /* This will satisfy all needs... */
  {
    window_main();  /* ...and open Application's main Window + implement Event handling by running 'runWindow()' */
  }
  cleanup();        /* Clean up stuff and exit */
} /* END main() */

Du findest dieses Tutorial hilfreich? Dann freue ich mich über einen kleinen Obolus für meine IT-Kasse. Besten Dank!  🙂

[Übersicht]

 

Aprikosen-Marmelade mit Wumms! www.mbergmann-sh.de

Aprikosen-Marmelade mit Wumms

Das ist eine meiner Lieblingsmarmeladen! Ihren unverwechselbaren Wumms bekommt sie durch einen guten Schluck Marillenlikör und eine Prise Muskat. Für bummelig 5 Gläser Marmelade brauchst du:

1,20 kg reife Aprikosen
2 EL Limettensaft
300 g Gelierzucker (3:1)
1 Prise Muskatnuss (frisch gerieben)
0,5 Stangen Zimt
ausreichend Marillenlikör
Vorbereitungen:
  1. Koche  5 bis 7 Schraubgläser à 300 ml (mit Twist-off Deckel) mit Wasser aus und lasse sie abtropfen
  2. Spüle Gläser und Deckel mit Mariellenlikör aus. Den guten Stoff anschließend nicht wegschütten!

Zubereitung:

  1. Aprikosen mit kochendem Wasser übergießen und die Fruchthaut abziehen.
  2. Früchte halbieren. Kern entfernen, Aprikosen in grobe Stücke schneiden. Früchte zusammen mit dem Zimt, dem Limettensaft, einer Prise Muskatnuss und 4 cl Marillenlikör in einem Topf zum Kochen bringen. Gelierzucker unter die Früchte rühren und weiterkochen lassen.  Stelle die vorbereiteten Gläser bereit
  3. Unter ständigem Rühren bei mittlerer Hitze ca. 3 Min. köcheln lassen (Gelierprobe!). Die Zimtstange entfernen und die Konfitüre mit einem Pürierstab fein pürieren. In die vorbereiteten Gläser mit Schraubverschluss füllen, je 1 cl Marillenlikör aufgießen und direkt verschließen.
  4. Gläser auf dem Deckel stehend auskühlen lassen.

Wichtig: Aprikosenmarmelade wird trotz der Zugabe von Zitronensaft gern leicht bräunlich. Daher am besten dunkel aufbewahren, das zögert den Farbwechsel etwas hinaus.


Du magst meine Rezepte und kochst sie gerne nach? Dann freue ich mich über einen kleinen Obolus für meine Gewürze-Kasse. Besten Dank!  🙂