Der AVR-/ARDUINO-Faden

[Bastelbruder]

Ich würde das Gehäuse mit Heißkleber zugloddern. Der läßt sich nach gemütlichem Aufwärmen im Backofen auf 150°C auch wieder problemlos auskippen.
Brateisen, Fön und Gewalt sind die falschen Mittel um Heißkleber zu entfernen.

Das erinnert mich an irgendwelche subversiven Nebelkerzen für elf Meter, die wurden (vor 35 Jahren) tatsächlich mit Wachs (unheimlich klebriges Nibrenwachs) vor dem Zugriff der Außenwelt geschützt. Heißkleber war damals noch nicht so richtig etabliert und die ersten Klebesticks waren zu der Zeit irgendein weiß-bröckeliges Zeug, das mit Feenstaub aufgewogen wurde.

Dieses Nibrenwachs wurde aus alten Indianer-Netzfiltern ausgeschmolzen, böse Zungen behaupten das enthalte PCB und sei Krebs erregend.

[Toddybaer]

Oder in eine Gießharzmuffe eingießen.
Da kommt kein Wasser rein aber man kommt auch nie mehr ran

[licht_tim]

Das soll ja nicht unter Wasser montiert werden. Sieh zu das kein Wasser von oben rein laufen kann aber etwas Luftaustausch möglich ist. Meine Led Platinen in den Außenlampen sehen nach jetzt 4 Jahren unverändert aus.

[grobschmied]

Ich hab mir jetz auch mal nen Arduino Nano bestellt diese Woche, heute Software installiert und getestet -> läuft Endlichmal wieder programmieren.
Ich hab noch die Pollin Platine für die Atmel im Keller, aber jedes mal in der Werkstatt den alten Laptop starten is auch nicht so das wahre. Jetz werd ich mir die ganzen Anleitungen und Beispiele für die Arduino zu Gemüte führen
Irgendjemand hat ja mal gesagt egal mit was, hauptsache mit programmiern anfangen

[Mino]

Hallo zusammen,

ich möchte eine ferngeschaltene Steckdose realisieren. Ein Schaltkontakt am „Sender“ soll ein Relais am „Empfänger“ schalten.

Als Hardware nutze ich zwei Wemos D1 mini Boards. Diese hängen an meinem Router.

Im Netz bin ich auf das hier gestossen:

https://www.instructables.com/id/WiFi-C ... sed-MCU-T/

Ich möchte jedoch ein „Zustandsbit“ übertragen.

Anbei der Code vom Client und vom Server:

Client:

Code: Alles auswählen

/*  Connects to the home WiFi network
 *  Asks some network parameters
 *  Sends and receives message from the server in every 2 seconds
 *  Communicates: wifi_server_01.ino
 */
#include <SPI.h>
#include <ESP8266WiFi.h>

byte ledPin = 2;
char ssid[] = "xxx";           // SSID of your home WiFi
char pass[] = "xxx";            // password of your home WiFi

unsigned long askTimer = 0;
byte kontakt = 0;

IPAddress server(192,168,2,220);       // the fix IP address of the server
WiFiClient client;

void setup() {
  Serial.begin(9600);               // only for debug
  WiFi.begin(ssid, pass);             // connects to the WiFi router
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println("Connected to wifi");
  Serial.print("Status: "); Serial.println(WiFi.status());    // Network parameters
  Serial.print("IP: ");     Serial.println(WiFi.localIP());
  Serial.print("Subnet: "); Serial.println(WiFi.subnetMask());
  Serial.print("Gateway: "); Serial.println(WiFi.gatewayIP());
  Serial.print("SSID: "); Serial.println(WiFi.SSID());
  Serial.print("Signal: "); Serial.println(WiFi.RSSI());
  pinMode(ledPin, OUTPUT);

  pinMode(0, INPUT_PULLUP);
  pinMode(4, OUTPUT);

}

void loop () {
  client.connect(server, 80);   // Connection to the server
  digitalWrite(ledPin, LOW);    // to show the communication only (inverted logic)
  Serial.println(".");
  client.println("Hello server! Are you sleeping?\r");  // sends the message to the server
  String answer = client.readStringUntil('\r');   // receives the answer from the sever
  Serial.println("from server: " + answer);
  client.flush();
  digitalWrite(ledPin, HIGH);
  delay(500);                  // client will trigger the communication after two seconds

  int sensorVal = digitalRead(0);

  if (sensorVal == HIGH) {
    digitalWrite(4, LOW);
    kontakt = 0;
  } else {
    digitalWrite(4, HIGH);
    kontakt = 1;
  }

  Serial.println (kontakt);
client.write (kontakt);

}

Server:

Code: Alles auswählen

/*  Connects to the home WiFi network
 *  Asks some network parameters
 *  Starts WiFi server with fix IP and listens
 *  Receives and sends messages to the client
 *  Communicates: wifi_client_01.ino
 */
#include <SPI.h>
#include <ESP8266WiFi.h>

byte ledPin = 2;
char ssid[] = "xxx";               // SSID of your home WiFi
char pass[] = "xxx";               // password of your home WiFi
WiFiServer server(80);

IPAddress ip(192, 168, 2, 220);            // IP address of the server
IPAddress gateway(192,168,2,1);           // gateway of your network
IPAddress subnet(255,255,255,0);          // subnet mask of your network

byte kontakt = 0;

void setup() {
  Serial.begin(9600);                   // only for debug
  WiFi.config(ip, gateway, subnet);       // forces to use the fix IP
  WiFi.begin(ssid, pass);                 // connects to the WiFi router
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  server.begin();                         // starts the server
  Serial.println("Connected to wifi");
  Serial.print("Status: "); Serial.println(WiFi.status());  // some parameters from the network
  Serial.print("IP: ");     Serial.println(WiFi.localIP());
  Serial.print("Subnet: "); Serial.println(WiFi.subnetMask());
  Serial.print("Gateway: "); Serial.println(WiFi.gatewayIP());
  Serial.print("SSID: "); Serial.println(WiFi.SSID());
  Serial.print("Signal: "); Serial.println(WiFi.RSSI());
  Serial.print("Networks: "); Serial.println(WiFi.scanNetworks());
  pinMode(ledPin, OUTPUT);

    pinMode(4, OUTPUT);
}

void loop () {
  WiFiClient client = server.available();
  if (client) {
    if (client.connected()) {
      digitalWrite(ledPin, LOW);  // to show the communication only (inverted logic)
      Serial.println(".");
      String request = client.readStringUntil('\r');    // receives the message from the client
      Serial.print("From client: "); Serial.println(request);
      client.flush();
      client.println("Hi client! No, I am listening.\r"); // sends the answer to the client
      digitalWrite(ledPin, HIGH);
    }
kontakt = client.read ();
Serial.println (kontakt);

  if (kontakt == 0) {
    digitalWrite(4, LOW);
  } else {
    digitalWrite(4, HIGH);
  }

    client.stop();                // tarminates the connection with the client
  }
}

Die Verbindung wird aufgebaut, beide Boards blinken nach dem Hochlauf synchron.
Im seriellen Monitor vom client wird „Kontakt“ mit 0/1 angezeigt, wenn ich den Schalter betätige.

Leider kommt im seriellen Monitor des servers nur 255 an, was bedeutet das nix empfangen wurde.

Ich bin ziemlich Anfänger was C angeht, also bitte ich um nachsicht

Weiß jemand wo das Problem liegt?




Schöne Grüße

Mino

[duese]

Wenn Du es selbst programmieren willst, nur zu.
Falls Du schnell nur durch Konfiguration zur Lösung kommen willst, empfehle ich nochmals ESPEasy. Das kann einfache Automatisierungsgeschichten auch alleine und Befehle zwischen verschiedenen Einheiten hin und her schicken.
Innerhalb eines ESP kann man mit den Rules Regeln zum Abarbeiten von Sachen bauen und mit SendTo kann man Events zwischen den Geräten hin und her schicken.

Also so in der Art:

Rules Gerät 1:

Code: Alles auswählen

on Button#State=1 do
      sendTo 2,event,PIN_einschalten
endon

Rules Gerät 2

Code: Alles auswählen

on PIN_einschalten do
     GPIO,15,1
endon

Alles konfigurierbar und anpassbar übers Web-Interface der Geräte.

[Mino]

NeinNeinNein…ich hab mir in den Kopf gesetzt das von Hand zu programmieren…ich gebe nicht auf
Trotzdem „danke“ für den Hinweis zu ESPeasy…muss ich mir echt mal anschauen.

Nach einigem Rumprobieren tut´s jetzt auch. Ich habe es leider nicht geschafft ein Datenbit/byte zu senden.
Da ein CHAR oder ein STRING jedoch nix anderes ist als ein „Datenbyte“ oder mehrere, sende ich einfach Text

Hier der Kern der Sache:

Client/Sender:

Code: Alles auswählen

int sensorVal = digitalRead(0);

    if (sensorVal == LOW) {
		client.println("zu\r");  				// sends the message to the server
		Serial.print("Status gesendet: "); Serial.println ("zu");
		digitalWrite(4, HIGH);
		}
	if (sensorVal == HIGH) {
		client.println("offen\r");  			// sends the message to the server
		Serial.print("Status gesendet: "); Serial.println("offen");
		digitalWrite(4, LOW);
		}

Server/Empfänger:

Code: Alles auswählen

 String request = client.readStringUntil('\r');    // receives the message from the client

		if (request == "offen") {
		digitalWrite(5, HIGH);
		}
		if (request == "zu") {
		digitalWrite(5, LOW);
		}
      Serial.print("Status Fenster: "); Serial.println(request);
      client.flush();

Das Ganze wird nun noch etwas mit Gehäuse aufgehübscht und dient dann zum ein/ausschalten der FBH wenn die Terrassentür offen ist.




Schöne Grüße

Mino

[Mino]

Hallo zusammen,

ich steh gerade ein bisschen aufm Schlauch oder vor einer imaginären Mauer und suche etwas Hilfe.

Ich habe ein Programm (Arduino IDE) welches auch soweit läuft. Sammelt ein paar Daten und schickt sie an nen Server.

Jetzt will ich aber diese Daten (5 Zahlenwerte) auf einer Homepage anzeigen lassen und 2 dieser Werte auch änderbar machen und als neuen Wert in den ESP8266 schreiben.

Dazu habe ich ein HTML Dokument erstellt (mein allererster Versuch in HTML ).


Das Problem ist nun wie ich das Ganze verheirate. Es gibt zig Anleitung aber irgendwie ist das für mich zu kryptisch bzgl. Daten an/von dem Browser aus dem Programm raus.
Hat jemand hierzu Erfahrung? Ich würde dann gerne in direkten Austausch gehen.



Besten Dank im Voraus.


Mino

PS: Das HTML hänge ich mal an...das C-Prog ist noch ungetestet/kompiliert. Habs grad nur in Notepad runtergetippt.
http://www.fingers-welt.de/imghost/up/2 ... OelV00.pdf
pdf -> html

[xanakind]

Ich stehe gerade auf dem schlauch.
Es geht um den nachbau von dem hier:
https://www.instructables.com/id/Window ... sing-RFID/

Ich habe die gleiche Hardware wie in dem Beispiel:
RC522+ Arduino Leonardo.
Das ganez ist ja wirklich für doofe wie mich gemacht, trotzdem geht es nicht

Also, ein bisschen geht es schon:

Ich kann im Serial Monitor die Karten auslesen. Das funktioniert prima.
Wenn ich das Programm so ändere, dass die Tastatureingabe sofort in einer schleife ausgegeben wird, geht auch das.
Die Hardware läuft also.
Wenn ich den Code aber stumpf mit copy & paste benutze, funktioniert nach dem eintragen der richtigen Karten ID nichts.
Noch nichtmal die RX-LED leuchtet.
Das kann doch nicht so schwer sein?

[ch_ris]

Ganz blöde Frage:
Eine Zahl mit dot suffix

Code: Alles auswählen

 200.

ist das ein Double oder Float?
In Java wäre das double daher die frage,
in der reference finde ich das nicht erklärt.

Muss ich die casten für float?

Code: Alles auswählen

(float)200

[xoexlepox]

Eine Zahl mit dot suffix

Ist sicher "floating point", aber alles andere ist "Spekulationssache" und von der Umgebung und dem Compiler abhängig. Für "platformunabhängigen Code" würde ich immer explizit casten.

[ch_ris]

Ja, erspart auch solche grübeleien

[ferdimh]

Meine Erinnerung sagt, dass das eben so wie "int" implementierungsabhängig die "übliche wortbreite" ist.
Ein Testprogramm sagt: sizeof(200.)=8
Auf meiner Kiste ist es also bei Fließkommazahlen ein double.
Wenn man eine bestimmte Wortbreite festlegen will, sollte man zwingend casten. Ich habe mir bisher aber eigentlich immer damit helfen können, die entsprechenden Ausdrücke so zu schreiben, dass es implizit klar ist.
So ist

Code: Alles auswählen

float x,y;
x=42;
y=200.*x;

uneindeutig. Die Berechnung wird als Double ausgeführt und dann auf float gecastet -> unnötig Zeit verschwendet.

Code: Alles auswählen

float x,y;
x=42;
y=x*200.

ist aber eindeutig, denn der vordere Operand gibt den Typ an. Blöd wurde das bisher nur bei Integern (Schiebeoperationen) und "1-Durch-Rechnen".

[Weisskeinen]

Code: Alles auswählen

float x,y;
x=42;
y=x*200.

ist aber eindeutig, denn der vordere Operand gibt den Typ an. Blöd wurde das bisher nur bei Integern (Schiebeoperationen) und "1-Durch-Rechnen".

Auch das ist nicht immer richtig. Zumindest vor einigen Jahren haben Intel- und Microsoft-Compiler den größten Datentyp in einem Ausdruck gesucht, alles dahin gecastet und dann erst die Berechnung ausgeführt. Dann bei Bedarf auf den Ziel-Datentyp zurück gecastet. Es lohnt sich auf jeden Fall, in die Compilerdokumentation zu schauen oder, wenn der Code auf jeden Fall portabel sein soll, explizit jeden Operanden zu casten.

Edit: Man kann den Typ der Konstanten auch vorgeben. Zum Bleistiel anstatt 200. zu schreiben 200.f für float oder 200.l für (long) double.

[ch_ris]

Ich zumindest meinte schon avr-gcc.

[Weisskeinen]

Hmmm, eigentlich ist das wohl gar nicht compilerspezifisch. Hier https://en.cppreference.com/w/c/language/conversion steht, wie's geht. Bei ferdimh's Beispielen sollte jedes Mal für die Berechnung nach double konvertiert werden und das Ergebnis dann nach float. Egal in welcher Reihenfolge das auftaucht. Sollte der GCC das nicht so machen, verhielte er sich nicht standardkonform.

[ch_ris]

Edit: Man kann den Typ der Konstanten auch vorgeben. Zum Bleistiel anstatt 200. zu schreiben 200.f für float oder 200.l für (long) double.

wußte ich nicht, wieder was gelernt.
Die C++ Bibel steht zwar im Regal und sieht schlau aus...

[ferdimh]

Bei ferdimh's Beispielen sollte jedes Mal für die Berechnung nach double konvertiert werden und das Ergebnis dann nach float.

Wo steht das? ich habe genau den Fall eben nicht gefunden...
Ein int wird zu einem double, das steht dort eindeutig (Double ist die "normale" Präzision). Ein float... gute Frage, ich bin mir ziemlich sicher, dass es so ist, wie ich gesagt habe, aber mir fällt auf die Schnelle weder eine Quelle noch ein Test ein.

[Weisskeinen]

Weil 200. laut C-Standard ein double ist und stets vor der Berechnung zum größten Typ, der in der Berechnung vorkommt, gecasted wird:

Code: Alles auswählen

2) Otherwise, if one operand is double, (...) the other operand is implicitly converted as follows:
      integer or real floating type to double

Die Reihenfolge ist egal. Vermeiden kann man das, indem man statt 200. 200.f schreibt.

[Rial]

LED-DOT-MATRIX

Habe aus der Räumung von Stitch ein paar Module ergattert.

Für die Displays habe ich einen Datenblatt gefunden.
https://www.velleman.eu/products/view/? ... e&id=16351

Aber leider finde ich nichts zu der Platine drunter.
Rückseite ist beschriftet mit :
WIBOND MM100 V2.0

Siehe Fotos

[Weisskeinen]

Hat hier schon mal jemand einen Arduino Pro Micro so programmiert, dass der sich als USB-Tastatur ausgibt und Befehle von einer Infrarot-Fernbedienung in Tastendrücke umwandelt?
Also wenn ich beispielsweise die Play-Taste auf der Fernbedienung drücke, wird ein Leerzeichen ausgegeben (wäre jetzt passend für den Media-Player-Classic). Das Steuerkreuz wird in Cursortasten umgewandelt, usw. usw..

[Sir_Death]

https://www.arduino.cc/en/Reference/KeyboardWrite

Das mit der IR-Library verhäkeln und fertisch

[sukram]

Früher(tm) hat man das mit einem TSOP1736 an der Seriellen und LIRC in Software gemacht... Bei den uc-net Leuten gibts auch irgendwo einen AVR basierten IR Multiempfänger, der diverse Fernbedienungsstandards automatisch empfangen und dekodieren konnte. Siehe Hier.

Bleibt nur noch das Anflanschen an USB. Hier habe ich aber keinen Überblick, was gerade aktuell ist

[Weisskeinen]

Ähm, ja, die Einzelteile kenne ich. Ich habe auch mal mit meinem Bruder zusammen einen IR-Empfänger gebaut, den man zwischen den PC und eine PS/2-Tastatur hängen konnte. Damit konnte man dann auch on-the-Fly die verschiedenen Tasten und Tastenkombinationen programmieren. Das bekäme ich wohl auch alles wieder hin, aber wenn's hier schon fertige Arbeit gäbe...
Ich habe mir gerade einige Watweissichduino Pro Micro-Boards bestellt. Mal sehen, wann die ankommen.

[Hightech]

<<<<<UPDATE>>>>>>>>>>>>>><<
Fehler 1 gefunden, es fehlte 1 Datei.
Moin, meine ersten Gehversuche mit arduinonono klemmen etwas, wer kann mir helfen?

Aber jetzt sowas:

Code: Alles auswählen

In file included from /home/boris/sketchbook/mqpub/mqpub.ino:2:0:
EtherCardMQTTS.h:98:3: error: 'prog_char' does not name a type
   prog_char* topic_name;
   ^
EtherCardMQTTS.h:107:21: error: 'prog_char' has not been declared
   void setTopicName(prog_char* topic_name);
                     ^
In file included from /home/boris/arduino-1.8.9/hardware/arduino/avr/cores/arduino/Arduino.h:28:0,
                 from sketch/mqpub.ino.cpp:1:
mqpub:19:21: error: variable 'gateway_host' must be const in order to be put into read-only section by means of '__attribute__((progmem))'
 char gateway_host[] PROGMEM = "test.mosquitto.org";
                     ^
/home/boris/sketchbook/mqpub/mqpub.ino: In function 'void setup()':
mqpub:46:36: error: no matching function for call to 'EtherCardMQTTS::setTopicName(const char*)'
     mqtts.setTopicName(PSTR("test"));
                                    ^
In file included from /home/boris/sketchbook/mqpub/mqpub.ino:2:0:
sketch/EtherCardMQTTS.h:107:8: note: candidate: void EtherCardMQTTS::setTopicName(int*)
   void setTopicName(prog_char* topic_name);
        ^
sketch/EtherCardMQTTS.h:107:8: note:   no known conversion for argument 1 from 'const char*' to 'int*'
/home/boris/sketchbook/mqpub/EtherCardMQTTS.ino: At global scope:
EtherCardMQTTS:66:35: error: variable or field 'setTopicName' declared void
 void EtherCardMQTTS::setTopicName(prog_char* topic_name)
                                   ^
EtherCardMQTTS:66:35: error: 'prog_char' was not declared in this scope
EtherCardMQTTS:66:46: error: 'topic_name' was not declared in this scope
 void EtherCardMQTTS::setTopicName(prog_char* topic_name)
                                              ^
/home/boris/sketchbook/mqpub/EtherCardMQTTS.ino: In member function 'void EtherCardMQTTS::sendRegister(byte*)':
EtherCardMQTTS:118:36: error: 'class EtherCardMQTTS' has no member named 'topic_name'
     strcpy_P((char*)&buf[6], this->topic_name);
                                    ^
EtherCardMQTTS:119:33: error: 'class EtherCardMQTTS' has no member named 'topic_name'
     buf[0] = 6 + strlen_P(this->topic_name);
                                 ^
exit status 1
'prog_char' does not name a type

Code: Alles auswählen

/*
 #include "EtherCardMQTTS.h"
#include <EtherCard.h>

#define BUF_SIZE      MQTTS_MAX_ETHER_LEN


byte mac[] = { 0x00, 0x04, 0xA3, 0x21, 0xCA, 0x38 };

uint8_t ip[] = { 192, 168, 1, 10 };
uint8_t dns[] = { 192, 168, 1, 1 };
uint8_t gateway[] = { 192, 168, 1, 1 };
uint8_t subnet[] = { 255, 255, 255, 0 };
uint8_t server[] = { 192, 168, 1, 1 };
byte Ethernet::buffer[BUF_SIZE];
uint32_t timer = 0;

// remote website name
char gateway_host[] PROGMEM = "test.mosquitto.org";

EtherCardMQTTS mqtts;


void setup(void)
{
    Serial.begin(9600);
    delay(1000);

    /* Check that the Ethernet controller exists */
    Serial.println("Initialising the Ethernet controller");
    if (ether.begin(sizeof Ethernet::buffer, mac, 8) == 0) {
        Serial.println( "Ethernet controller NOT initialised");
        while (true)
            /* MT */ ;
    }

    /* Setup IP address */
    ether.staticSetup(ip, gateway, dns);
    ether.printIp("My IP: ", ether.myip);
    ether.printIp("GW IP: ", ether.gwip);

    /* Set the MQTT-S server address */
    mqtts.setServer(server);

    /* Set the topic to publish to */
    mqtts.setTopicName(PSTR("test"));

    return;
}


void loop(void)
{
    word len = ether.packetReceive();
    mqtts.packetLoop(len);

    // publish time every 2 seconds
    if (millis() > timer) {
        timer = millis() + 2000;
        mqtts.publish(
          millis()
        );
    }
}

[Hightech]

Hihi
Geht es Arduiono ist stille im Saloon....

Ich habs gefunden, prog_char soll man ersetzen durch const char, dann soll es gehen. Mal sehen, ob der kompilierte Schmuddel funktioniert.

[Weisskeinen]

Ich muss mich hier mal etwas über die besch******* Arduino-Libraries auslassen, die mitgeliefert werden. Insbesondere die USB-Keyboard-Library.
Ich bin ja dabei, eine IR-Fernbedienung an meinen PC zu häkeln. Die Idee ist, dass der Arduino (Pro Micro mit einem Atmega32U4) die Infrarotsignale empfängt und dekodiert. Der hängt außerdem an einem USB-Port und gibt sich als Tastatur aus. Eigentlich ja ganz einfach, eine IR-Empfangs-Lib (da https://www.instructables.com/id/USB-IR ... op-Laptop/ gefunden und da https://github.com/z3t0/Arduino-IRremote runterladbar) drauf und je nach Code den entsprechenden Tastencode senden, damit das mein PC-Fernsehglotzprogramm oder der Videoplayer versteht.
Nun ist es aber so, dass diese /$&($)(&$§&%&%$**'*+ Keyboard-Lib nur US-Tastaturen unterstützt und bei einem deutschen Tastaturlayout einigen Blödsinn macht. Nu ja, auch darum hat sich mal jemand gekümmert und deutsche Tastaturen etwas nutzbarer gemacht: https://github.com/MichaelDworkin/Ardui ... ch-library.
Dummerweise gehen immer noch nicht so wichtige (Multimedia-)Tasten wie lauter, leiser, Mute, ...
Auch da hat schon mal jemand was gemacht: https://www.stefanjones.ca/blog/arduino ... edia-keys/ + https://github.com/stefanjones/Arduino/ ... es/arduino. Dummerweise für eine uralte Arduino-Version, so dass bei der aktuellen NIX mehr passt. Glücklicherweise haben die Arduino-Heinis die verschiedenen notwendigen Klassendefinitionen und -Deklarationen so umgewurschtelt, dass sich die Ergänzungen jetzt alle in der neuen deutschen Keyboard-Library vornehmen lassen. Und jetzt endlich versteht mein PC die Infrarotfernbedienung

[IPv6]

Gibt keinen Grund sich drüber auszulassen. Du hast kein Produkt mit irgendeinem Support gekauft worüber du Anspruch auf alle librarys nach deinen Wünschen hast.
Wird alles von der Community für die Community gemacht.
Und du hast deine Änderung vermutlich nirgends umfangreich dokumentiert und veröffentlicht, wie alle anderen, die den Bedarf vorher hatten, auch. Somit darf sich jeder erneut drüber aufregen, bis irgendwann jemand was Angepasstes zur Verfügung stellt. Du könntest nun diese Person sein.
Für andere Plattformen hättest du das immerhin komplett von Grund auf schreiben dürfen....

[Fritzler]

Is eben alles von Makern für Maker, da kannste keine Qualität erwarten.

[IPv6]

So kann mans auch formulieren
Aber Fritzler, wie war das nochmal mit dem Code den man von STM bereitgestellt bekommt?

[Fritzler]

Herstellerlibs sind mindestens genauson Dreck.
Das Atmel ASF und Softpack sind auch BÄH.

Ein Detail zum STM32 HAL:
Was haben die bitte geraucht um in die Configstructs uint32_t reinzumachen statt einem getypten enum?
1. typsicher
2. eine gescheide IDE schlägt einem dann die enum Member vor, jetzt kannste das per Hand suchen...

und die Bugs erst.
Auf einem STM32L431 ist die HAL Clock Config im Ar***.
Den Code hat der Cube so erzeugt:

Code: Alles auswählen

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
//RCC_OscInitStruct.PLL.PLLM = 1;                    << wird von CubeMX nicht inited und steht daher auf 0 -> HAL nimmt defaultwert von 2, aber die PLL bekommt 1 im Reg
RCC_OscInitStruct.PLL.PLLN = 10;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;

Dadurch war dann die UART Baudrate im Poppes, weil der UARt Init die CLK Warte rückwärts ausließt.

[IPv6]

...und damit wieder zurück zum Thema
Wir halten fest: schlechten Code gibts überall. Nimm was du kriegst und lebe damit. Aber auch brauchbaren Code gibt es auf jeder Plattform.
Oder schreib dir alles nach deinen Wünschen selbst. Alles.

[Weisskeinen]

Und du hast deine Änderung vermutlich nirgends umfangreich dokumentiert und veröffentlicht, wie alle anderen, die den Bedarf vorher hatten, auch. Somit darf sich jeder erneut drüber aufregen, bis irgendwann jemand was Angepasstes zur Verfügung stellt. Du könntest nun diese Person sein.

Zunächst mal sind die Libraries eigentlich schon gut abgehangen und Tastaturlayouts abseits vom US-Layout sind ja auch nicht ganz neu. Deshalb hätte ich jetzt schon wesentlich mehr erwartet. Ist aber eher so wie auf dem RasPi das raspistill, das als Nonplusultra zur Kameraansteuerung angesehen wird, aber eigentlich nur als krudes Demo programmiert wurde und sich auch so verhält.
Was die Veröffentlichung angeht, da müssen wir mal sehen. Wenn sich da zu viele Hürden auftun (nein ich kaufe dafür keinen eigenen Webspace), könnte es schon sein, dass ich das nicht veröffentliche. Ich würde aber gerne...
Dokumentation ist relativ einfach, weil im wesentlichen zusammen kopiert und Klassenaufrufe angepasst.

P.S.: Welche Laus ist dir denn über die Leber gelaufen?

[IPv6]

Deshalb hätte ich jetzt schon wesentlich mehr erwartet.

Aber von wem denn genau?
Das hat doch irgendwer auch mal erstellt, weil er das gebraucht hat. Und dann hat er es den anderen Nutzern zur Verfügung gestellt, weil er es als nützlich angesehen hatte. Vielleicht hat das später auch mal jemand erweitert oder in die "Standard"bibliotheken aufgenommen. Wenn die Leute halt alle aus den Staaten waren gibts das halt im US Layout. Und nur weil da jemand vor Jahren mal was geschrieben hat heißt das noch lange nicht, dass er das auch weiterhin pflegen muss.

P.S.
Keine Laus über die Leber, wirklich nicht. Mich stört nur das "Meckern" über solche Projekte, die man kostenlos nutzen kann. Und ja, auch ein wenig die Anspruchshaltung. Die Librarys sind nicht beschissen, nur weil sie in deinen Augen unvollständig sind und du sie nicht 1:1 für deine Zwecke nutzen kannst.
Ist doch wie an einem "Zu verschenken" Stand. Ich zahle nichts, hat irgendwer dort hingestellt. Ich kann vielleicht was davon brauchen, dann nehme ich es. Oder ich kann es vielleicht als Grundlage nehmen, um was Neues draus zu machen. Aber ich kann mich nicht beschweren, das nicht genau das dabei ist, was ich gerade brauche.
Anders sieht das durchaus bei Code von Herstellern aus, da kaufe ich schließlich genau das Produkt, weil ich weiß, was es an Support dazu gibt und das sollte dann auch wie angedacht funktionieren. Hinter "Arduino" verbirgt sich aber kein solcher Hersteller, das ist eine open source Hard- und Softwareplattform.

P.P.S.
Ja, der Tag war lang. Höchste Zeit fürs Bett.
Ich wünsche euch eine gute Nacht

[Hightech]

Ist das denn ein Problem, das deutsche Layout umzubiegen?

[Weisskeinen]

Das Problem an der Library ist, dass sie eigentlich nur die ersten 128 ASCII-Zeichen in Scancodes umwandelt und alles andere als Sonderbelegungen betrachtet, sog. Modifier, also Strg, Alt, AltGr, .... Die Scancodes einer Tastatur hängen aber von der Lage der Tasten ab, nicht davon, was oben drauf steht. Jetzt liegen aber halt je nach Layout unterschiedliche Tastenfunktionen an den entsprechenden Stellen und die Auswertung ist relativ tief in den Libraries, die auf Libraries aufbauen, die andere Libraries benutzen, die (etc. etc. pp.) vergraben. Der Autor der deutschen Version hat versucht, die wichtigsten Tasten umzumappen und nutzbar zu machen, so dass ein Zeichen aus einem String vom Arduino auch die richtige Ausgabe am auf deutsch eingestellten PC erscheint. Das wurde reichlich komplex und funktioniert wohl nicht für alle gewünschten Zeichen.
Um das Verhalten komplett ordentlich zu machen, mit passenden Codepages oder so, müsste man das wohl alles komplett neu programmieren. Vielleicht hat das sogar schon mal jemand gemacht, das aber dann nicht veröffentlicht (oder ich hab's nicht gefunden, kann auch sein). Als ich mir gestern aber mal die USB-HID-Spezifikationen angesehen habe, könnte ich verstehen, warum nicht. Das ist wohl alles andere als trivial, aber es gibt ja auch viele Leute, die viel besser programmieren können, als ich... (und das auch noch mit mehr Leidenschaft machen, die ist mir in den letzten Jahren etwas abhanden gekommen...)

[Fritzler]

Guck dir doch mal V-USB an.
Das kann auch eine Tastatur emulieren, direkt auf Fußpilz äh Scancodebene.
Du musst dich sogar um "gedrückt" und "losgelassen" kümmern.
Funktioniert dafür aber auch

Die Subprojekte hießen glaube sogar direkt:
HID-Keys
USB Volume Control
RC-5 Remote

[Weisskeinen]

Hmmm, ja, muss ich mal machen. Ich hoffe, das passt dann einigermaßen mit den Routinen zusammen, die schon für den nativen USB-Port des 32U4 existieren...

[Fritzler]

NOPE! Null Komma ganich!
V-USB ist USB per GPIO Bitgeklimper

[Weisskeinen]

Ja, weiß ich. Aber vielleicht (man kann ja mal Glück haben) haben die Programmierer davon auch gewisse Ebenen eingehalten, was wo wie hardwarenah ist und das einigermaßen kompatibel gestaltet. So nach dem Motto: schicke diesen Deskriptor an den Host, packe jene Antwort in den Buffer, der bei der nächsten Anfrage übertragen wird, so was halt. Die eine Implementierung macht das dann in Software und die andere in Hardware... (man wird ja noch mal träumen dürfen...)

[Fritzler]

Das is schon schwieriger als du denkst
Haste denn schon das DB zum 32U4 durchgelesen wegen der USB HW?

[Weisskeinen]

Nein habe ich nicht. Ich träume ja von Kompatibilität auf höherer Ebene. Ich wollte da jetzt wirklich nicht zu tief in die Programmierung eines USB-Clients einsteigen. Dafür gibt es zu viele andere Dinge, die ich lieber machen möchte...

[Später Gast]

N'abend,

ich bin endlich mal dazu gekommen mich an meinen Lärm-Moderator (shit, schon 3 Jahre her ) ranzusetzen, und habe folgenden Verhau zusammengeklatscht:


Zur Funktion:

Der Sensor zieht bei erreichen von per Trimmer einstellbarem Pegel seinen Ausgang auf LOW. Da das immer nur sehr kurz der Fall ist, hat er einen Puffer, dessen Wert sieht man im Display links. Wird die Schwelle überschritten gibts 20 Abzug, sonst +1 bis der Puffer wieder voll ist. Werte gehen von +50 bis -99. Bei negativem Puffer zählt der Countdown rechts runter, das sind 7 Sekunden, bei jeder vollen Sekunde macht der Lautsprecher einmal Möps.
Wenn der Puffer wieder positiv ist, wird wieder bis 7 hochgezählt, dabei macht der Lautsprecher etwas leiser Mips. Wenn der Puffer negativ ist, leuchten außerdem noch 2 rote Highpower-LED. (unter dem weißen Papier, sonst blendets, proportional zum Pufferwert)
Der Lautsprecher hängt mittlerweile mit nem kleinen Vorwiderstand am L293D weil der Audio Verstärker den ganzen Müll vom Systemtakt und PWM auch verstärkt hat. So ist das Teil jetzt komplett still, wenns nicht gerade über den Lärm meckert. Der Sound ist immernoch gut genug, bzw häßliche Töne sind hier ja erwünscht.
Verwende die [ tone (Pin, Frequenz); noTone (Pin); ] Funktion, je nach Zeit, die das zum Laufen bekommt, macht das unterschiedliche Geräusche, die nicht zwangsweise mit der angegebenen Frequenz in Verbindung stehen. Das tönt jetzt schon ganz brauchbar, verbessern könnte man das aber auch, wenn man wollte.

Wenn der Countdown 0 erreicht gibts nen Alarm (Sequenz aus verschiedenen Tönen) und rechts von der Buffer-Anzeige geht ein Zähler hoch, wie oft schon alarmiert wurde.
Nach dem Alarm wird der Puffer auf 40 und der Countdown auf 2s gesetzt, damits nicht gleich wieder bimmelt. Von der Idee Ultraschall /hohe, für mich nicht hörbare Töne zu verwenden bin ich abgekommen. Störer bekommen einen Moderator (werde mehrere bauen, für bessere räumliche Auflösung) auf den Tisch, und wenn der Zähler bei 5 ist, gibts Strafarbeit, braucht keine unsichtbare Disziplinierung, zumal die auch unbeteiligte trifft.

Ich habs jetzt natürlich noch nicht in freier Wildbahn laufen lassen. Für mich alleine ist es schwierig, einen vollen Kunstsaal zu simulieren. Mit Musik als Lärmquelle klappts jedenfalls. Wenn man die Empfindlichkeit zu hoch stellt, gibts nen Feedback-Loop und der Puffer kommt nicht mehr hoch. Ich hoffe aber, dass das im Gehäuse nachher nicht mehr problematisch ist, weil ich da Dämpfungsmaßnahmen einsetzen werde. Wie laut oder leise es vor Ort wirklich ist kann ich nicht abschätzen.

Ich vermute auch, dass da (spannungsmäßiger)Dreck in der Versorgung die Messung beeinflusst, die PWM der LEDs war mit dem kleinen Verstärker recht deutlich zu hören. Hab mal nen Elko spendiert. Mein Fädelchaos hilft bestimmt auch nicht.
Macht es überhaupt Sinn, zu versuchen, dem Sensor ne sauberere Versorgung zu basteln?
So richtig zufrieden bin ich mit der Pegelmessung und dem dazugehörigen visuellen Feedback noch nicht. Hab mal noch analoge Mikrophon-Bausteine geordert, da sollte sich das ja feiner mit messen lassen. Dann wollt ich den Lautstärke"Zeiger" vllt über Dotmatrix machen. Die ständig wechselnden Zahlen lassen sich eher schlecht lesen und die notwendige Asymmetrie im PlusMinus-Spiel macht ihr übriges. Hat jemand schlaue Ideen, wie man die Pegelmessung etwas sprungärmer und nachvollziehbarer machen könnte?

Grüße
Moritz

[Sunset]

Für eine Schätzung, wie laut/leise es im Raum ist kann man Apps auf dem Schmierphone nutzen.
Schau mal im Appstore nach Schallpegel.

Beim Testen zu Hause kannst Du dann die gleiche App laufen lassen und mit dem Radio oder so einen entsprechenden Pegel als Background (notfalls rauschen) einstellen.

[Später Gast]

Jo, sone Apps hab ich eh schon gar viele installiert, weil ich das Thema jeden Tag auf der Arbeit habe. Rauschen ist glaub n guter Tip. Habs mal mit Gitarrespielen gestestet und es war schon etwas störrisch. Manchmal hab ich garnicht (bewusst) lauter gespielt und es zählte runter bis zum Alarm, andersrum hat teilweise lauteres Spielen kaum was bewirkt. Beim Rauschen weiß man wenigstens, dass das schonmal nicht die Fehlerquelle ist.

Werd auch mal versuchen, ob ich die Asymmetrie im Pufferverhalten nicht zumindest teilweise ausgleichen kann, indem ich den Sensor empfindlicher stelle.

[Später Gast]

Sodele, bin etwas weitergekommen.
Zum Einen hab ich mal mit Pyphox den Pegel im Klassenzimmer gemessen. -30db war angenehm, -20laut, -10 unerträglich. Dann hab ich mir hier in Meinem Musikprogramm Reason nen Synthi "gebastelt", der Rauschen erzeugt und dessen Lautstärke ich mit nem Drehregler einstellen kann. Und dann hab ich mal gleichzeitig gerauscht und Das Gerät zuhören lassen.

Das lief erstmal nicht wie geplant, weil die bereits erwähnte PWM zuviel in die Versorgung reinstört und damit der Lärmsensor anschlägt. Sobald Die LED leuchten hat der Sensor dauerhaft Fehlalarm. Die LED kurz auskommentieren brachte Klarheit, ohne LED kein Problem mehr. Als Workaround leuchten die LED jetzt nurnoch, wenn gerade der Buzzer lärmt. Da jedoch dessen (ekelektrischer) Lärm ebenfalls vom Sensor "gehört" wird, werden während des Buzzens/Leuchtens die Abzugs/Additionswerte auf 0 gesetzt. danach isses wieder +1/-10.

Ich würde gerne das Mikro noch etwas länger stumm schalten damit nicht nur elektrischer, sondern auch akustischer Lärm gemutet wird, aber mit meiner stümperhaften Programmierkenntnis ist das grade alles inline (heißt das so?)

Code: Alles auswählen

if (sevennum == 9 && debSensor < 0 ){
          AddiVal = 0;        //Feedbackvermeidung
          AbzugVal = 0;
          //digitalWrite (Buzzer, HIGH) ;// Buzzer On
          analogWrite(ledPin1, leuchtVal);
          tone (7, 220);          
          delay (1) ;// Delay 1ms
          noTone (7);
          //digitalWrite (Buzzer, LOW) ; // Buzzer Off 
          AddiVal = 1;
          AbzugVal = 10;
          analogWrite(ledPin1, 0);
      
      }
   if (sevennum == 0 && debSensor > 0 && countnumber != 0 && countnumber < 700){
          AddiVal = 0;        //Feedbackvermeidung
          AbzugVal = 0;
          analogWrite(ledPin1, 5);                      //digitalWrite (Buzzer, HIGH) ;// Buzzer On           
          tone (7, 3000);
          //digitalWrite (Buzzer, LOW) ;// Buzzer Off 
          noTone (7);
          AddiVal = 1;
          AbzugVal = 10;
          analogWrite(ledPin1, 0);

Bin mir noch nichtmal sicher, ob das überhaupt was bringt, oder ich mich nur selber verarsche. Allerdings läuft das jetzt. Gucke DuRöhre

So wie das programmiert ist kommt [ tone(7, 220)] nicht wirklich dazu, seine Frequenz tatsächlich auch abzuspielen. Was man hört ist das An/Aus von tone(7,egalwas), aber wie gesagt fällt mir nicht ein, wie ich das besser lösen soll, mir fehlt das Vokabular...

Die Visualisierung des Lautstärkepuffers ist blöd mit den Zahlen, da such ich noch was anderes, Vllt sone Dot-Matrix, da hab ich nur noch keine mit Max7219 und RGB LED als Paket gefunden. Hat Jemand schon Erfahrungen mit diesen einzeln ansteuerbaren LedStrips?

Ich würd da gerne 10-er Blocks runterschnippeln und dann damit den Puffer in grün(+) und rot(-) anzeigen. Geht das?

Grüße
Mo

[ch_ris]

für die anzeige würd ich ein zeiger instrument nehmen. ist einfacher.
der delay ist zu kurz und eh blöd, du hältst die schleife ja damit an.
besser wär ein timer mit zeitstempeln.also:
ton an;
time =millis +100..
if time>=millis...........ton aus .
....oder so in der art.

[Später Gast]

für die anzeige würd ich ein zeiger instrument nehmen. ist einfacher.

Das wäre ja dann analog? Teufelszeug!
Einfach ist nicht unbeding das Kriterium, das soll ja für die Schüler am Tisch (will mindestens 4 davon bauen und im Klassenzimmer an laute Tische positionieren) möglichst eindeutiges und intuitiv verständliches Feedback abliefern. Grünes Licht=alles OK, Rotes =Nope!
Deswegen Designkriterien groß und gut sichtbar, ohne dass es Konzentration beim Ablesen braucht.

der delay ist zu kurz und eh blöd, du hältst die schleife ja damit an.
besser wär ein timer mit zeitstempeln.also:
ton an;
time =millis +100..
if time>=millis...........ton aus .
....oder so in der art.

okay, danke, werd ich mal probieren. Dass die Schleife angehalten wird, hab ich zähneknirschend in Kauf genommen. Wird keiner nachmessen, ob das jetzt tatsächlich korrekt die Sekunden zählt oder nicht.

Ich habe mein "PWM auf der Versorgung"- Lärmproblem vorerst gelöst indem ich dem Lärmsensor 330 ohm vor Vcc und 100μF zwischen Gnd und Plus gehängt habe. Quick and dirty Der hört jetzt nurnoch Schall, das werd ich dann mal mit obiger Methode angreifen.

Spätestens wenn die analogen Sensoren da sind, wird das aber nichtmehr reichen. Aber dann könnte ich ja den gleichen Trick wiederverwenden, nur diesmal zwischen dem Großverbraucher(L293D mit Led und Lautsprecher) der seinen Strom halt verschmutzt, und der Messtechnik, die davon abgezwackt gereinigten Strom bekommt?
Separate Wandler für 2x 5V kommt mir doof vor, L293D direkt an den Akku und Vorwiderstände für Lautsprecher und LED wäre noch ne Variante

[sysconsol]

Ich hätte da ein Arduino-Problem, welches beim Crowdcontrol-Faden aufgetreten jedoch Arduino-spezifisch ist:
(zudem dürften hier mehr Leute reinschauen)

Da gibt es millis() und millis.

Die millis lassen mir keine Ruhe - ohne Arduino ist das blöd, da muss man erst einen ATmega328 in SMD-Ausführung freiluftverdrahten

Aber jetzt:

Code: Alles auswählen

long unsigned int puffer1;

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.print("millis(): ");
  Serial.println(millis());
  Serial.print("millis: ");
  //Serial.println(millis); //--> wirft: no matching function for call to 'println(long unsigned int (&)())'

  puffer1 = millis;
  Serial.println(puffer1);

  delay(10000);
}

Sieht im Terminal Monitor so aus:

Code: Alles auswählen

millis(): 0
millis: 95
millis(): 10000
millis: 95
millis(): 20000
millis: 95
millis(): 30001
millis: 95
millis(): 40001
millis: 95
millis(): 50001
millis: 95
millis(): 60002
millis: 95
millis(): 70003
millis: 95
millis(): 80004
millis: 95
millis(): 90004
millis: 95
millis(): 100004
millis: 95
millis(): 110005
millis: 95
millis(): 120005
millis: 95
millis(): 130007
millis: 95
millis(): 140007
millis: 95
millis(): 150007
millis: 95
millis(): 160008
millis: 95
millis(): 170009
millis: 95
millis(): 180009
millis: 95
millis(): 190010
millis: 95
millis(): 200010
millis: 95
millis(): 210011
millis: 95
millis(): 220012
millis: 95
millis(): 230012
millis: 95
millis(): 240013
millis: 95
millis(): 250013
millis: 95
millis(): 260014
millis: 95
millis(): 270015
millis: 95
millis(): 280015
millis: 95
millis(): 290016
millis: 95

Was hat es mit millis auf sich?
Bleibt jedenfalls bei 95 - da hilft auch kein Resetten.

Im Netz finde ich nur millis().

Einer von uns beiden ist ein Depp: Das Netz oder ich.

Edit: Eine Erklärung zur Herkunft der millis() im µC eXperiment-Blog.
Und bei stackexchange.
Immerhin ist da eine 95 zu finden

[Anse]

Was hat es mit millis auf sich?
Bleibt jedenfalls bei 95 - da hilft auch kein Resetten.

Ohne die Programmiersprache von Arduino zu kennen. Es könnte der Funktionspointer auf Millis(); sein.