PlantUML is also able to generate Gantt. You can test it at: https://www.planttext.com

Above are all available elements I found in PlantUML to build gantts.

@startgantt
Project starts the 5th of august 2019
saturday are closed
sunday are closed
2019/08/15 is closed
[Prototype designx] as [TASK1] lasts 6 days
[TASK1] is colored in Lavender/LightBlue
[Prototype design] lasts 13 days
[Prototype completed] happens at [Prototype design]'s end
[Test prototype] lasts 14 days
[Test prototype] starts at [Prototype design]'s end
[Prototype design] is colored in Fuchsia/FireBrick
[Test prototype] is colored in GreenYellow/FF0000
[Ein Vorgang] starts at [Prototype designx]'s end
[Ein Vorgang] lasts 5 days
[Ein Vorgang2] starts at 15th of august 2019
[Ein Vorgang2] lasts 7 days
[Ein Vorgang3] starts at [Ein Vorgang2]'s end
[Ein Vorgang3] lasts 5 days
[Ein Vorgang4] lasts 9 days
[Ein Vorgang5] lasts 6 days
[Ein Vorgang4] starts at 2019/08/17
[Ein Vorgang5] starts 5 days after [Ein Vorgang2]'s start
[Task1] on {Alice} lasts 10 days
[Task2] on {Bob:50%} lasts 2 days
then [Task3] on {Alice:25%} lasts 1 days
@endgantt

Habe überlegt wie man solch eine Rampe am besten selber bauen kann. Was so angeboten wird ist ziemlich teuer.

Die Lösung war neben dem Brett mit der Höhe der Türschwelle, ein Elektrohobel. Dann frei Hand, einen sanften Aufstieg modellieren. Und … siehe Video

Christian, a colleague createted a very nice project with an arduino and an e-ink display:
https://www.brokoko.eu/kitchen-clock-with-public-transport-schedule/

How to connect an Arduino to a raspberry pi via USB bidirectional.

The raspberry reads all from the serial and prints it. Next it reads a textile from a webpage and sends the text (one word) to serial, next a random car to the Arduino. Arduino got a LCD attached and shows the data it got via serial. It sends back the seconds it run and a string. The example is at this time without real use, it is just for testing the bidirectional serial connection.

Using Python on the raspberry side. Change the port to what you find out:

import serial
import time
import random
import urllib2
import feedparser
 
def read_all(port, chunk_size=200):
    """Read all characters on the serial port and return them."""
    if not port.timeout:
        raise TypeError('Port needs to have a timeout set!')

    read_buffer = b''

    while True:
        # Read in chunks. Each chunk will wait as long as specified by
        # timeout. Increase chunk_size to fail quicker
        byte_chunk = port.read(size=chunk_size)
        read_buffer += byte_chunk
        if not len(byte_chunk) == chunk_size:
            break

    return read_buffer
#end def

cars = ["Ford", "Volvo", "BMW", "VW"]

ser = serial.Serial(
    port = '/dev/ttyACM0',
    baudrate = 9600,
    parity = serial.PARITY_NONE,
    stopbits = serial.STOPBITS_ONE,
    bytesize = serial.EIGHTBITS,
    timeout=0.5, # IMPORTANT, can be lower or higher
    )

#s = serial.Serial('/dev/ttyACM0', 9600) # Namen ggf. anpassen
#s.flushInput()
#s.open()

time.sleep(2) # der Arduino resettet nach einer Seriellen Verbindung, daher 

ser.write("xyx")


d = feedparser.parse('http://www.reddit.com/r/news/.rss')
dlen = len(d['entries'])
dnr = 0
try:
    while True:
        nb = "01234567890123456789012345678901"
        text = "nn.mm"
        data_str = []
        data_str = read_all(ser)
        print(data_str) 
        #nb = raw_input('Choose it: ')
        #nb = cars[random.randint(0,3)] + "x"
        try:
            #nb = d['entries'][dnr]['title'].encode('utf-8').strip() + "x"
            nb = d['entries'][dnr]['title'].encode('utf-8').strip() 
            dnr += 1 
            if (dnr > dlen -1):
                d = feedparser.parse('http://www.reddit.com/r/news/.rss')
                dlen = len(d['entries'])
                dnr = 0
            #ser.write(nb)
        except:
            print("fehler1")
        try: 
            response = urllib2.urlopen('http://4johannes.de/weather/lowest.txt')
            text = response.read().strip()
            print(text)
        except:
            print("fehler2")
        ll = len(text)
        text2 = text + " " + nb[0:33-ll] + "\n"
        #print(text2)
        #ser.write(text2)
        #time.sleep(5)
        #text2 = nb[16-ll:33-ll] + "y"
        print(text2)
        print(nb)
        ser.write(text2)
        time.sleep(5)
except KeyboardInterrupt:
    ser.close()

And this is the Arduino part:

/*********************

Example code for the Adafruit RGB Character LCD Shield and Library

This code displays text on the shield, and also reads the buttons on the keypad.
When a button is pressed, the backlight changes color.

**********************/

// include the library code:
#include <Wire.h>
#include <Adafruit_RGBLCDShield.h>
#include <utility/Adafruit_MCP23017.h>


// The shield uses the I2C SCL and SDA pins. On classic Arduinos
// this is Analog 4 and 5 so you can't use those for analogRead() anymore
// However, you can connect other I2C sensors to the I2C bus and share
// the I2C bus.
Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

// These #defines make it easy to set the backlight color
#define RED 0x1
#define YELLOW 0x3
#define GREEN 0x2
#define TEAL 0x6
#define BLUE 0x4
#define VIOLET 0x5
#define WHITE 0x7

byte nr;
char myString[] = "Hello MArius";
String readString;
long previousMillis = 0;
long interval = 1000;

void setup() {
// Debugging output
Serial.begin(9600);
// set up the LCD's number of columns and rows: 
lcd.begin(16, 2);

// Print a message to the LCD. We track how long it takes since
// this library has been optimized a bit and we're proud of it :)
int time = millis();
lcd.print("Hello, Marius!");
time = millis() - time;
//Serial.print("Took "); Serial.print(time); Serial.println(" ms");
lcd.setBacklight(WHITE);
lcd.setCursor(0, 1);

}

uint8_t i=0;
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
//lcd.setCursor(0, 1);
// print the number of seconds since reset:
//lcd.print(millis()/1000);


unsigned long currentMillis = millis();

if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED 
previousMillis = currentMillis;
//do nothing at the moment 
//Serial.println(millis()/1000);

}

nr = 1;

if (Serial.available() > 0) {
//nr = Serial.read();
//myString = Serial.readln();
//Serial.print("Folgender char wurde empfangen: ");
//Serial.println(nr, DEC);

char c = Serial.read(); //gets one byte from serial buffer
readString += c; //makes the string readString
//lcd.setCursor(5,1);
//lcd.print(readString);
//lcd.print(c);
//readString = "";

if (c == 'x') {
lcd.setCursor(0,1);
lcd.print(" <");
lcd.setCursor(0,1);
lcd.print(readString);
Serial.println(millis()/1000);
Serial.println("x/n");
readString = "";

}

}

uint8_t buttons = lcd.readButtons();


if (buttons) {
lcd.clear();
lcd.setCursor(0,0);
if (buttons & BUTTON_UP) {
lcd.print("UP ");
lcd.setBacklight(RED);
}
if (buttons & BUTTON_DOWN) {
lcd.print("DOWN ");
lcd.setBacklight(YELLOW);
}
if (buttons & BUTTON_LEFT) {
lcd.print("LEFT Marius");
lcd.print(nr);

lcd.setBacklight(GREEN);
}
if (buttons & BUTTON_RIGHT) {
lcd.print("RIGHT Paulina");
lcd.setBacklight(TEAL);
}
if (buttons & BUTTON_SELECT) {
lcd.print("SELECT ");
lcd.setBacklight(VIOLET);
}
}
}

Using PLSQL for setting Grants:

CREATE OR REPLACE FUNCTION set_all_sq_grants() RETURNS SETOF TEXT AS
$BODY$
DECLARE
r record;
BEGIN
FOR r IN
SELECT sequence_name, sequence_schema FROM information_schema.sequences WHERE sequence_schema = 'xxx'
LOOP
-- can do some processing here
EXECUTE ' Grant all on ' || r.sequence_schema || '.' || r.sequence_name || ' to userXY' ;
--RETURN NEXT r; -- return current row of SELECT
END LOOP;
RETURN;
END
$BODY$
LANGUAGE plpgsql;

— und ausführen
select xxx.set_all_sq_grants();

more about Postgres PLSQL: Fun with Functions.