The post Wie funktioniert ein Breadboard – Neues YT-Short appeared first on Creatronix.

The post Die wichtigsten Transistor-Gehäusetypen – YT-Short appeared first on Creatronix.

Klar, wenn man sich etwas auskennt, hört man das schon noch raus. Ich finde es aber trotzdem beeindruckend und gruselig zugleich 👻 Was meint ihr?

The post Neues YouTube-Short: LCR-Tester von JoyIT appeared first on Creatronix.

Nachdem ich mich einige Zeit mit der Entwicklung eines eigenen Motorcontrollers beschäftigt habe, möchte ich hier euch die Grundlagen von H-Brücken erklären.

Eine H-Brücke ist eine elektronische Schaltung, die es einem ermöglicht, die Richtung und Geschwindigkeit eines Gleichstrommotors zu steuern.

Vereinfachte Darstellung mit Schaltern

Man kann eine H-Brücke als eine Art Schalter betrachten. In der einfachsten Form besteht die Brücke aus vier Schaltern (S1, S2, S3, S4), die in einer H-Form angeordnet sind.
Wenn alle Schalter offen sind, fließt kein Strom durch den Motor.

Wenn S1 und S4 geschlossen sind, fließt der Strom in eine Richtung durch den Motor, wodurch er sich in eine Richtung dreht.

Wenn S2 und S3 geschlossen sind, fließt der Strom in die entgegengesetzte Richtung, wodurch sich der Motor in die andere Richtung dreht.

Wenn jedoch S2 und S4 geschlossen sind, fließt der Strom nicht durch den Motor, was zu einem Kurzschluss führen würde.

Das nennt man auch shoot-through. Den gilt es zu vermeiden

Ersetze Schalter durch Transistoren

Da wir die Schalter nicht manuell betätigen wollen, ersetzen wir sie durch Transistoren.

Die Transistoren fungieren als elektronische Schalter, die durch ein Steuersignal (z.B. von einem Mikrocontroller) aktiviert werden können.

Warum MOSFETs?

MOSFETs (Metal-Oxide-Semiconductor Field-Effect Transistors) sind besonders geeignet für H-Brücken, da sie eine hohe Schaltgeschwindigkeit und geringe Verlustleistung bieten. Sie können mit niedrigen Spannungen gesteuert werden und haben eine hohe Stromtragfähigkeit, was sie ideal für Motorsteuerungen macht.

Es werden normalerweise selbst-sperrende Typen verwendet, das heißt im ungeschalteten Zustand leiten die Transistoren nicht.

Es gibt MOSFETs als n-Kanal und p-Kanal-Variante. In einer perfekten Welt würden wir nur n-kanal MOSFETs verwenden, da sie effizienter sind.
Sie haben im eingeschalteten Zustand einen niedrigeren Widerstand RDS als p-kanal MOSFETs und benötigen eine niedrigere Gate-Spannung, um vollständig zu leiten. In der Praxis ist es jedoch schwieriger, eine H-Brücke nur mit n-Kanal-MOSFETs zu realisieren, da die High-Side-Transistoren, um vollständig zu leiten, eine Gate-Spannung benötigen, die höher als die Spannung am Source ist.

Deshalb können wir eine Kombination aus n-Kanal- und p-Kanal-MOSFETs verwenden.

Freilaufdioden

Freilaufdioden sind notwendig, um die Induktionsspannung des Motors abzufangen, wenn der Motor abgeschaltet wird.
Andernfalls könnte die Induktionsspannung die MOSFETs beschädigen.

Zusammenfassung

Dies war ein erster kleiner Ausflug in die Welt der H-Brücken. Die gezeigten Schaltungen sollen das Prinzip verdeutlichen und eignen sich noch nicht für eine praktische Umsetzung, da noch Widerstände und Gate-Treiber fehlen. Dazu mehr in diesem Artikel

The post Wie funktioniert eine H-Brücke? appeared first on Creatronix.

In meinem Line Follower Roboter Projekt habe ich mit dem Motortreiber L298N gearbeitet. Da Module mit diesem Treiber auf eine Leistung von maximal 25 Watt limitiert sind, musste für unser Azubi-Projekt ein anderer Treiber her.

Die Anforderungen waren mit 50 Watt pro Motor und einer Vollbrücke nicht besonders hoch, aber der Teufel steckt ja bekanntlich im Detail. Der erste Treiber, der Cytron SmartDriveDuo MDDS30 war mit 40A / 300W stark überdimensioniert. Er ist uns trotzdem nach ein paar Wochen abgeraucht.
Der nächste Versuch mit dem Soldered DRV8424P war auch nicht von Erfolg gekrönt. Wir haben erst nach ein paar Tagen herausgefunden, dass der falsche Chip bestückt wurde. Auch bei der Nachlieferung war das der Fall, anscheinend war die ganze Charge des Lieferanten falsch.

Also schnell aus der Not eine Tugend machen und selber einen Treiber entwerfen.

Anforderungen

Der Motortreiber soll sich zur Ansteuerung mit Arduino GPIOs via TTL-Pegel eignen. Er soll zwei 2 Kanäle mit jeweils 50 Watt Leistung haben und via PWM in der Geschwindigkeit regelbar sein. Die Betriebsspannung soll zwischen 18 und 24 Volt liegen.

Recherche

Nach dem Schauen von dutzenden Videos und Lesen von einigen Blog-Artikeln habe ich den Beitrag von Alexander Egger gefunden:
https://www.aeq-web.com/arduino-mosfet-h-bruecke-dc-motor-steuern-mit-drehrichtung-und-geschwindigkeit-vierquadrantensteller/
Dieser Artikel erschien mir sehr gut als Absprungbasis geeignet.

Schaltungsentwurf – Revision 1

Im ersten Versuch habe ich die Schaltung von Alex mit Fritzing nachgebaut. Als Transistoren habe ich für die High Side die im Artikel erwähnten IRF9540 benutzt. Für die Low Side habe ich IRLZ44N verwendet, da die L-Versionen für Logikpegel geeignet sind, weil sie bei 5V VGS schon durchschalten. Zusätzlich habe ich vier 1N4007 als Freilaufdioden eingebaut:

Daraus habe ich dann eine erste Platine gelayoutet:

Aus Fritzing heraus, konnte ich direkt eine Platine bei Aisler fertigen lassen. Mindestabnahmemenge sind 3 Stück. Bei einem Gesamtpreis von knapp 20€ ein sehr interessanter Anbieter. Da die Produktion und Lieferung 2,5 Wochen dauern sollte, habe ich parallel dazu die Schaltung auf einem Breadbaord aufgebaut und getestet.

Hierbei ist mir dann aufgefallen, dass ich die p-kanal MOSFETs falsch herum eingezeichnet hatte.

Das konnte ich beim Bestücken der Platine -die doch bereits nach 10 Tagen eingetroffen war- noch halbwegs elegant beheben.

Lasttest

Ich habe mich langsam herangetastet, einfacher 5V Motor mit wenigen 100mA Last.
Dann den richtigen Motor bei 24V betrieben. Leider konnte ich keinen echten Lasttest durchführen.
Die Schaltung lief aber stabil bei 12-15Watt Leistungsaufnahme.
Die Transistoren haben sich dabei auf ca 40° Celsius erwärmt.

Lasttest Nummer 2

Um mal die Platine richtig zu stressen, habe ich eine elektronische Last drangehängt.

Hierbei hat sich dann der Steckverbinder des Jumnperkabels verabschiedet, da die Zuleitung für mehr als 1 Ampere überfordert war. Das bedeutet die Spannungsversorgung über die Pin Header ist nicht optimal.

Schaltungsentwurf – Revision 2

Nicht lang snacken, Kopp inn Nacken! Im zweiten Wurf wollte ich dann die Spannungsversorgung auch über eine WAGO-Klemme realisieren.
Zudem sind noch ein paar Optimierungen möglich. Die Freilaufdioden sollten näher an den MOSFETs platziert werden. (Danke Hubert für den Tip!)
Es fehlten noch die Montage-Löcher, um die Platine sinnvoll zu befestigen. Für die WAGO-Klemme hatte ich den falschen Footprint benutzt, sodass ich zum verlöten von der Klemme zwei Beinchen abzwicken musste. Duh!

Schematic

Da mir die Möglichkeiten mit fritzing etwas eingeschränkt vorkommen, habe ich mich in KiCAD eingearbeitet. Die Lernkurve ist etwas steiler, aber machbar.

Die Schaltung habe ich fast eins zu eins von den Schematics aus fritzing ins KiCAD übertragen. (Und die p-Kanal-Mosfets richtig herum angeschlossen LOL)

Der Standard-Header hat jetzt einen Pin mehr, da er die Betriebsspannung ans Logik-Board übertragen muss. Dazu später mehr.

PCB-Layout

Beim PCB Layout habe ich mich an der ersten Version orientiert, habe aber die Freilaufdioden näher an die MOSFETs platziert. Für die Leistung die Leiterbahnbreite auf 2 mm erhöht.

Im 3D-Viewer kann man schön sehen, ob die Teile gut positioniert sind.

Auch diese Platine habe ich wieder bei Aisler bestellt. Perfekter Service.

Bestückung

Beim Bestücken ist mir aufgefallen, dass ich für die Bipolar-Transistoren den schmalen Footprint genommen habe. Das macht das Löten etwas anstrengender, aber noch ok.

Lasttest

Beim Lasttest konnte ich eine Leistung von knapp 50 Watt abrufen, ohne dass sich die MOSFETS überhitzt haben.
Die p-Kanal MOSFETs werden mit 65°C jedoch deutlich wärmer als die n-Kanal (45°C)

Steuerungssoftware

Für die PWM-Ansteuerung habe ich mich am Programm von Alex orientiert, allerdings etwas optimiert und für eine Anbindung an ein Python-Programm mit GUI erweitert.

const byte P_FET_Q1 = 2;
const byte N_FET_Q4 = 3; // PWM controlled
const byte P_FET_Q3 = 8;
const byte N_FET_Q2 = 9; // PWM controlled

byte current_PWM_port = N_FET_Q4;

void setup()
{
    //This sets frequency to 7812.5 hz.
    TCCR0B = TCCR0B & 0b11111000 | 0x01; 

    pinMode(P_FET_Q1, OUTPUT);
    pinMode(N_FET_Q2, OUTPUT);
    pinMode(P_FET_Q3, OUTPUT);
    pinMode(N_FET_Q4, OUTPUT);
    Serial.begin(9600);
} 

Am Anfang werden alle Pins deklariert und als Output gesetzt.
Wie auch bei meinem Line Follower setze ich die PWM-Frequenz auf 7kHz.

void forward()
{
    digitalWrite(N_FET_Q2, LOW);
    digitalWrite(P_FET_Q3, LOW);
    digitalWrite(P_FET_Q1, HIGH);
    current_PWM_port = N_FET_Q4;
}

digitalWrite ist hier sehr nützlich, weil es relativ langsam ausgeführt wird.
Die 4–5 µs Verzögerung, die durch den Funktionsaufruf entstehen, wirken hier wie eine kurze Dead Time.

Fazit & Ausblick Rev3

Da ich beim Testen von beiden Platinen die Spannungsquelle ein paar Mal falsch herum angeschlossen hatte, sollte in Revision 3 ein Verpolungsschutz hinzukommen. Eine Beschriftung der WAGO-Klemme ist natürlich auch sinnvoll.
Zudem hätte ich auch gerne eine Indikator-LED, die mir anzeigt, dass die Schaltung mit Spannung versorgt wird. Zwei LEDs, die die Drehrichtung anzeigen, werde ich auch einbauen. Bei Rev1 und Rev2 fehlen auch die Bezeichnungen an den Digital-Eingängen, sodass ich beim Testen immer rätseln musste, welcher Pin welchen Transistor ansteuert.

Da die Schaltung außerdem nicht gegen shoot-through gesichert ist, muss das derzeit Software-seitig passieren. Für Revision 3 werde ich noch eine Logikschaltung entwerfen, die sicherstellt, dass nur die korrespondierenden Hi- und Lo-Side gleichzeitg aktiv werden können.

Last but not least werde ich versuchen, die Platine in SMD-Technik zu layouten.

Arduino-Code

Hier der komplette Arduino Code:

const byte P_FET_Q1 = 2;
const byte N_FET_Q4 = 3; // PWM controlled
const byte P_FET_Q3 = 8;
const byte N_FET_Q2 = 9; // PWM controlled

byte current_PWM_port = N_FET_Q4;

void setup()
{
    //This sets frequency to 7812.5 hz.
    TCCR0B = TCCR0B & 0b11111000 | 0x01; 

    pinMode(P_FET_Q1, OUTPUT);
    pinMode(N_FET_Q2, OUTPUT);
    pinMode(P_FET_Q3, OUTPUT);
    pinMode(N_FET_Q4, OUTPUT);
    Serial.begin(9600);
}

void stop()
{
    analogWrite(current_PWM_port, 0);
}

void forward()
{
    digitalWrite(N_FET_Q2, LOW);
    digitalWrite(P_FET_Q3, LOW);
    digitalWrite(P_FET_Q1, HIGH);
    current_PWM_port = N_FET_Q4;
}

void backwards()
{
    digitalWrite(P_FET_Q1, LOW);
    digitalWrite(N_FET_Q4, LOW);
    digitalWrite(P_FET_Q3, HIGH);
    current_PWM_port = N_FET_Q2;
}

void drive(byte speed)
{
    analogWrite(current_PWM_port, speed);
}

void loop()
{
 if (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');

    if (cmd.startsWith("PWM:")) {
      int value = cmd.substring(4).toInt();
      if (value < 0) {
        backwards();
        value = -value;
      } else {
        forward();
      }
      value = constrain(value, 0, 255);
      drive(value);
    } else if (cmd == "STOP") {
      stop();
    }
  }

}

The post Wir bauen einen eigenen Motorcontroller appeared first on Creatronix.

Standardmäßig wird der Raspberry Pi nicht mit einem Kühler geliefert. Für kleine Projekte ist das kein Problem, aber wenn du den Raspberry Pi für längere Zeit belastest, kann er überhitzen.
In diesem Artikel zeige ich dir, wie du die Temperatur deines Raspberry Pi überwachen kannst.

“vcgencmd” sollte bei einer offiziellen Distribution von Raspbian dabei sein.
Es ist ein Befehl, der von der Raspberry Pi Foundation bereitgestellt wird, um Informationen über die Hardware des Raspberry Pi zu erhalten.

Installation

Falls du keine offizielle Distribution von Raspbian hast, kannst du das Paket libraspberrypi-bin installieren.
Du installierst das Paket mit folgendem Befehl:

sudo apt install libraspberrypi-bin

Konsolen-Kommando

Nun kannst du die Temperatur mit folgendem Befehl kontrollieren:

vcgencmd measure_temp

Automatisiertes Überwachen

Wenn wir die Temperatur regelmäßig überwachen wollen, können wir das mit dem watch Befehl machen:

watch -n 5 vcgencmd measure_temp

Das -n 5 gibt an, dass der Befehl alle 5 Sekunden ausgeführt wird.

Kühlkörper und Lüfter

Wenn du deinen Raspberry Pi kühl halten möchtest, kannst du auch einen Kühlkörper installieren.
Die gibt es sowohl als passiv gekühlte Variante, als auch mit einem Lüffter.
Bei Amazon findest du eine große Auswahl an Kühlkörpern und Lüftern für den Raspberry Pi.
Beispiel: Körper und Lüffter für Raspberry Pi

Fazit

Der vcgencmd Befehl ist ein nützliches Tool, um die Temperatur des Raspberry Pi zu überwachen.
Er kann auch für andere Informationen über die Hardware des Raspberry Pi verwendet werden.

The post So kontrollierst du die CPU Temperatur am Raspberry Pi appeared first on Creatronix.

In diesem Artikel zeige ich euch, wie wir einen Line Follow Roboter mit Arduino bauen können.

Die Idee hinter diesem Roboter ist es, mit zwei IR-Sensoren eine schwarze Linie zu erkennen und den Roboter entsprechend zu bewegen.

Teile

Um den Linienverfolgungsroboter zu bauen, benötigen wir das yourDroid 2WD Smart Car Chassis für DIY Roboter.

Außerdem benötigen wir einen Arduino Uno

zwei IR-Sensormodule,

ein L298N Motortreiber-Modul mit doppelter H-Brücke,

4 Doppel-A Akkus und einige Jumper-Kabel.

Für den Parcours brauchen wir ein großes helles Brett und schwarzes Gaffertape für die Linie.

Werkzeug

Ein guter Lötkolben oder eine Lötstation, Lötzinn und eine Heißklebepistole sind sehr hilfreich.
Falls ihr keine Heißklebepistole habt, könnt ihr auch doppelseitiges Klebeband benutzen.
Ich benutze für dieses Projekt eine Abisolierzange, ihr könnt aber auch eine kleine Schere oder ein Messer zum abisolieren nehmen.

Zusammenbau

Zuerst löten wir Drähte an die Getriebemotoren. Dann montieren wir die zwei Motoren am Auto.

Wir befestigen jetzt das Motortreiber-Modul. Ich hatte hier noch ein paar passende Schrauben, aber kleben geht natürlich auch

Jetzt stecken wir die Räder auf die Achsen der Motoren. Nun befestigen den Arduino Uno mit der Heißklebepistole.

Auf der anderen Seite des Chassis können wir die Batteriebox ankleben. Wir zerschneiden den roten Draht von der Batteriebox und entfernen den Mantel mit der Abisolierzange.

Nun Löten wir die Batterieanschlussdrähte an den Schalter und stecken den Schalter in die Platte.

Wir verbinden die Anschlüsse der Motoren mit dem Motortreiber-Modul

Nun Befestigen wir die zwei IR-Sensoren vorne am Auto mit Winkeln. Die Winkel habe ich mit Tinkercad erstellt und mit meinem 3D-Drucker gedruckt. Du kannst natürlich auch hier wieder die Heißklebepistole benutzen.

Elektrische Verbindung

Jetzt machen wir eine Verbindung wie im Schaltplan.

• Wir verbinden das L298N-Motortreiber-Moduls mit den Arduino Uno-Pins.
• Schließe Drähte der Batteriebox an die Plus-5-Volt- und Masse-Pins des Motortreiber-Moduls an.
• Wir nehmen Plus-5-Volt und Masse vom Motortreiber-Modul und versorgen damit auch die zwei IR-Sensoren sowie den Arduino Uno.
• Verbinde die rechten und linken IR-Sensor-Ausgangs-Pins mit D11 und D12 am Arduino.

Software

Lasst uns jetzt einen kurzen Blick auf den Code werfen.

const byte MOTOR_SPEED = 210;
const byte DELTA = 45;

Die Motorgeschwindigkeit setzen wir auf 210 und das Delta auf 45. Damit bleiben wir im Bereich der PWM von 0 bis 255.
Nun definieren die Variablen für die Eingangs- und Ausgangspins.

const byte SPEED_RIGHT_MOTOR = 6;
const byte SPEED_LEFT_MOTOR = 5;

const byte RIGHT_MOTOR_PIN1 = 7;
const byte RIGHT_MOTOR_PIN2 = 8;

const byte LEFT_MOTOR_PIN1 = 9;
const byte LEFT_MOTOR_PIN2 = 10;

const byte IR_SENSOR_RIGHT = 11;
const byte IR_SENSOR_LEFT = 12;

Setup

void setup()
{
    //This sets frequency to 7812.5 hz.
    TCCR0B = TCCR0B & B11111000 | B00000010;
    pinMode(SPEED_RIGHT_MOTOR, OUTPUT);
    pinMode(RIGHT_MOTOR_PIN1, OUTPUT);
    pinMode(RIGHT_MOTOR_PIN2, OUTPUT);

    pinMode(SPEED_LEFT_MOTOR, OUTPUT);
    pinMode(LEFT_MOTOR_PIN1, OUTPUT);
    pinMode(LEFT_MOTOR_PIN2, OUTPUT);

    pinMode(IR_SENSOR_RIGHT, INPUT);
    pinMode(IR_SENSOR_LEFT, INPUT);

    digitalWrite(LEFT_MOTOR_PIN1, HIGH);
    digitalWrite(LEFT_MOTOR_PIN2,LOW);

    digitalWrite(RIGHT_MOTOR_PIN1, HIGH);
    digitalWrite(RIGHT_MOTOR_PIN2, LOW);

}

Innerhalb der Setup-Funktion müssen wir die PWM-Frequenz höher einstellen. Dies ist ein sehr wichtiger Schritt, da das Problem bei TT-Getriebemotoren darin besteht, dass sie sich bei einem sehr niedrigen PWM-Wert gar nicht drehen.
Dies ändert die Frequenz des PWM-Signals an den Pins D5 und D6 auf 7800 Hertz, wodurch der Motor bei niedriger Geschwindigkeit und hohem PWM-Wert kontrolliert läuft.
Innerhalb der Setup-Funktion setzen wir auch alle Motorpins als Ausgang, die Pins der IR-Sensoren als Eingang.

Loop

void loop()
{

    int rightIRSensorValue = digitalRead(IR_SENSOR_RIGHT);
    int leftIRSensorValue = digitalRead(IR_SENSOR_LEFT);

    //If none of the sensors detects black line, then go straight
    if (rightIRSensorValue == LOW && leftIRSensorValue == LOW)
    {
        driveStraight();
    }
    //If right sensor detects black line, then turn right
    else if (rightIRSensorValue == HIGH && leftIRSensorValue == LOW )
    {
        turnRight();
    }
    //If left sensor detects black line, then turn left
    else if (rightIRSensorValue == LOW && leftIRSensorValue == HIGH )
    {
        turnLeft();
    }
    //If both the sensors detect black line, then stop
    else
    {
        stop();
    }
}

In der Loop-Funktion lesen wir die Werte der rechten und linken IR-Sensoren mit der digitalRead-Funktion.

• Wenn beide Werte niedrig sind, bedeutet das, dass der Sensor die schwarze Linie nicht erkannt hat und wir vorwärtsfahren wollen.
• Wenn der rechte Sensor die schwarze Linie erkennt, sind wir zu weit links und wir lassen den linken Motor etwas schneller und den rechten etwas langsamer drehen.
• Wenn der linke Sensor die schwarze Linie erkennt, dann machen wir es genau umgekehrt: rechts schneller und links langsamer.
• Wenn beide Sensoren die schwarze Linie erkennen, dann beide Motoren stoppen.

Video

Links

Source Code / Diagramm

https://github.com/jboegeholz/line_follow_robot_tutorial

Winkel für IR-Sensoren

https://www.printables.com/de/model/695860-ir-sensor-holder

Teile

bei Roboterbausatz

https://www.roboter-bausatz.de/p/yourdroid-2wd-smart-car-chassis-fuer-diy-roboter
https://www.roboter-bausatz.de/p/uno-r3-atmega328p-atmega16u2-board-arduino-kompatibel
https://www.roboter-bausatz.de/p/ir-infrarot-sensor-hinderniserkennung-abstandssensor
https://www.roboter-bausatz.de/p/l298n-motortreiber-mit-doppelter-h-bruecke

Bei Amazon (Affiliate-Links)

Chassis 2WD

Arduino-Klon

AZDelivery 3 x IR Infrarot Modul für Hinderniserkennung

Motor Drive Controller Board-Modul L298N

4x AA Wiederaufladbare Akkus

The post Wir bauen einen Line Follow Roboter mit Arduino appeared first on Creatronix.

ls /dev/tty* | grep usb

in my case I got

/dev/tty.usbserial-14120

Now we can connect via screen:

screen /dev/tty.usbserial-14120 115200

When you reset the board you should see something like this

configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3fff0030,len:5656
load:0x40078000,len:12696
load:0x40080400,len:4292
entry 0x400806b0

To end the session in screen, press Ctrl+a, and type :quit and press Enter.

Further Reading

Install ESP32 in ArduinoIDE

Using MicroPython on FireBeetle ESP32

Mailbox IoT ESP 32 Project

The post How to connect to your ESP32 on macos appeared first on Creatronix.

In my project Mailbox IoT ESP 32 Project I needed a Telegram bot to relay the messages.

So here is a short tutorial

Create TG bot

1. Open Telegram
2. Search for @botfather
3. Start chat
4. Send /newbot
5. Pick a name
6. Pick a username (must be unique)
7. Receive credentials

Chat with your bot

Now you can search for your bot’s name and send a message

Python test Program

Telegram has a nice python package which you can pip install

pip install python-telegram-bot --upgrade

import telegram 
bot = telegram.Bot(token='<your_token>') 
if __name__ == '__main__': 
    print(bot.get_me()) 
    bot.send_message(chat_id="<your_chat_id>", text="Post ist da")

This program is just to used to test the connectivity of your bot.

Because we don’t have access to the telegram package inside the ESP / MicroPython environment we use urequests.

urequests

The telegram package isn’t available on the ESP32 / microPython, so we send our requests with the microPython port of the requests package called urequests.

Sending messages

import urequests
requests.get("https://api.telegram.org/bot<your_token>/sendMessage?text=hallo&chat_id=<your_chat_id>")

Lets clean up the code a bit:

try:
    import urequests as requests
except ModuleNotFoundError:
    import requests

TOKEN = "<your_token"
URL = f"https://api.telegram.org/bot{TOKEN}/"
CHAT_ID = "<your_chat_id"

def send_message(text, chat_id):
    url = f"{URL}sendMessage?text={text}&chat_id={chat_id}"
    response = requests.get(url)
    content = response.text
    return content

if __name__ == '__main__':
    print(send_message("Your parcel arrived", CHAT_ID))

References

https://makeblock-micropython-api.readthedocs.io/en/latest/public_library/Third-party-libraries/urequests.html

The post Telegram Bot with MicroPython appeared first on Creatronix.

>>> os.name
Traceback (most recent call last):
File "", line 1, in 
AttributeError: 'module' object has no attribute 'name'
>>> import platform
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: no module named 'platform'

UOS for the rescue

uos is a port of the standard Python packages os and platform to MicroPython.
You can use it by importing the package like this

import uos

One handy function is uname:

uos.uname()

It gives you information about your system in my case about the esp32 and the microPython version:

https://docs.micropython.org/en/latest/library/uos.html

The post MicroPython uos package appeared first on Creatronix.