Het grote ESP topic

[pc_freak1]

Sabbi schreef op vrijdag 15 april 2022 @ 09:58:
@Waah Ik zou alle strips in een lange slang aansluiten, dat is veel makkelijker te bekabelen en weg te werken, voor 2 meter ledstrip heb je geen power injection halverwege nodig.
Je kan speciale connectors kopen maar als het nooit meer los hoeft zou ik het gewoon solderen.
(maar dan natuurlijk met 3/4 aders tussen de losse strips)

dit geeft wel het probleem dat de laatste LED's veel minder fel zijn dan de eerste.
het eerdere design is wat dat betreft veel beter.

[Sabbi]

pc_freak1 schreef op vrijdag 15 april 2022 @ 10:04:

dit geeft wel het probleem dat de laatste LED's veel minder fel zijn dan de eerste.
het eerdere design is wat dat betreft veel beter.

Aan de foto's te zien is dit nog geen twee meter ledstrip, de spanningsval daarover is niet heel relevant, helemaal als je een 12 volt strip gebruikt. Als je echt zeker wilt zijn kan je nog een extra kabeltje van de voeding naar het andere eind van de slang laten lopen maar elke 30cm is echt complete overkill.

[Waah]

Sabbi schreef op vrijdag 15 april 2022 @ 09:58:
@Waah Ik zou alle strips in een lange slang aansluiten, dat is veel makkelijker te bekabelen en weg te werken, voor 2 meter ledstrip heb je geen power injection halverwege nodig.
Je kan speciale connectors kopen maar als het nooit meer los hoeft zou ik het gewoon solderen.

[Afbeelding]
(maar dan natuurlijk met 3/4 aders tussen de losse strips)

Dat was eerst het plan, maar dan moet ik dus de draad van achter de kast laten lopen, naar voren brengen, zijwaarts de strip in, andere kant de strip uit....
Maar direct naar boven is dan lastig, waardoor ik weer terug moet naar achter, om de plank en weer naar voren.

Zo dus:


Alle draden voor kan ook, dan hoef ik niet steeds achteruit en vooruit... maar dan zit ik weer met: Hoe werk ik die draden mooi weg? Sowieso ben ik daar nog niet over uit. De ledstrip kan ik wel vrij onzichtbaar uit het zicht krijgen met een hoekprofiel. Maar de draden die van achter naar voren lopen niet.

Mijn eigen idee was dus zo:

Dat leek me een stuk minder gekronkel, en de kabels zijn dan misschien makkelijker weg te werken.
Maar vandaar de vraag: Hoe werken jullie dat soort kabels weg? Ook in het geval met 1 draad die je erdoor kronkelt... Alles in een gootje?

[Raymond P]

Waah schreef op vrijdag 15 april 2022 @ 11:40:
[...]
Hoe werken jullie dat soort kabels weg? Ook in het geval met 1 draad die je erdoor kronkelt... Alles in een gootje?

Niet. Ik vraag mijn vriendin wat voor kleur kabel ze wilt zien.
Ik heb nog steeds meters roze UTP van de eerste keer dat ik dat vroeg.

Als het uit zicht moet zou je kunnen overwegen een (aluminium) U-profiel over de voorste lat te laten lopen en daar je meuk in verwerken.

[Septillion]

Atmoz schreef op donderdag 14 april 2022 @ 06:53:
Het wordt dus omgezet van HEX naar ASCII:

Dat komt omdat je String gebruikt. Voor dit soort zaken wil je String vermijden als de pest

Daar het geen string is maar raw data zou ik er zelf liever ook geen string (aka char[]) voor pakken omdat ik niet weet of de boel wel netjes afgesloten is met een null-char. Prop het eens in een byte[] array. Wel dus zelf zorgen dat de array tijdens compilen groot genoeg is voor alle data die je erin wilt lezen. En bij het sturen naar de browser ook zelf over de array loopen omdat je er dus niet vanuit mag gaan dat de sw weet waar het einde van de array is.

Later zou je wel dynamisch een array kunnen maken met malloc() maar wees je er dan van bewust dat het geheugen niet eindig is en dat je makkelijk gatenkaas van je geheugen maakt.

[ Voor 11% gewijzigd door Septillion op 15-04-2022 13:22 ]

[Septillion]

@Waah Is dat Ikea Kallax? Zo ja, dan zou je met een lange boor door de dikke zijwand kunnen boren. Die zijn gemaakt van karton dus dat moet makkelijk gaan. Daarna alleen even pielen om de draad erdoor te krijgen. Wil hetzelfde ook nog steeds doen met mijn Besta kast.

[Waah]

Raymond P schreef op vrijdag 15 april 2022 @ 12:13:
[...]


Niet. Ik vraag mijn vriendin wat voor kleur kabel ze wilt zien.
Ik heb nog steeds meters roze UTP van de eerste keer dat ik dat vroeg.

Als het uit zicht moet zou je kunnen overwegen een (aluminium) U-profiel over de voorste lat te laten lopen en daar je meuk in verwerken.

Dat is ook een oplossing ja
Helaas heb ik zelf een hekel aan (duidelijk) zichtbare kabels. Maar iets van een heel klein U-profiel zou nog een oplossing kunnen zijn.

Septillion schreef op vrijdag 15 april 2022 @ 14:32:
@Waah Is dat Ikea Kallax? Zo ja, dan zou je met een lange boor door de dikke zijwand kunnen boren. Die zijn gemaakt van karton dus dat moet makkelijk gaan. Daarna alleen even pielen om de draad erdoor te krijgen. Wil hetzelfde ook nog steeds doen met mijn Besta kast.

Oeh das nog best een goed idee
Ik heb een Praxis- variant. Die heeft ook een dik middenstuk Dus met een lange boor (ff zien hoe ik goed recht kan boren) zou ik die draden wel kwijt kunnen. Zo achter het hoekprofiel

[Atmoz]

CurlyMo schreef op donderdag 14 april 2022 @ 21:09:
[...]

Daarvoor heb je drie opties:
- C++ String gebruiken
- C malloc & free
- Een vaste grootte aan statische buffer ergens anders dan in PROGMEM.

Realiseer je je wel dat (grote) geheugenallocaties op een ESP potentieel tot geheugen fragmentatie crashes kan leiden.

Stel je voor dat ik bijvoorbeeld 150KB als max zou gaan accepteren (door "vooraan aan de poort" c.q. het webinterface gewoonweg niet meer te laten inladen), welke methode is dan het beste?

Dan \0 terminate je de nieuwe string niet of je geeft een verkeerde grootte aan.

Ik terminate inderdaad helemaal niets. Ik schrijf gewoon de nieuwe data over het bestaande array dat tijdens het compileren in PROGMEM wordt gezet. Als ik dat (bij kortere nieuwe data) wel zou terminaten, zou de nieuwe array dan gewoon netjes korter zijn? En wat gebeurt er dan met de "rest data" die eigenlijk nog erachteraan kwam? Daar ben ik wel zéér benieuwd naar eigenlijk... Erg interessant ook!

Nee, dan krijg je buffer overflows wat vaak tot crashes leidt.

Ok, om dat tegen te gaan zal ik gewoon zorgen dat de data nooit te groot kan worden.

Dat is niet te zeggen. Als dat het enige doel is en je zeker weet dat je dat geheugen ten alle tijde vrij houdt, dan kan je dat gewoon doen en dan is dat misschien ook wel verstandig om geheugen fragmentatie crashed te voorkomen. Ik reserveer voor een bepaald project 16KB aan geheugen uit de 2nd heap juist om die reden.

Tja is eigenlijk, kan de ESP32 goed omgaan met zulke grote array's die tijdens runtime pas worden gedeclareerd? Dus pakweg van zo'n 150KB. Is dat goede memory-management voor aanwezig? Want als dát zo is, en het is niet gek om gewoon tijdens runtime 1 zo'n grote array aan te maken, dan is dat natuurlijk ook gewoon een (makkelijke) oplossing!

Overigens mist hier nog de HTML upload functionaliteit

Die had ik al werkend. Dat is gewoon een stukje code van ergens op internet waarmee je bestanden via een webform kunt uploaden naar SPIFFS. Als je dit wilt doen kan ik het uiteraard posten...

Septillion schreef op vrijdag 15 april 2022 @ 13:20:
[...]

Dat komt omdat je String gebruikt. Voor dit soort zaken wil je String vermijden als de pest

Daar het geen string is maar raw data zou ik er zelf liever ook geen string (aka char[]) voor pakken omdat ik niet weet of de boel wel netjes afgesloten is met een null-char. Prop het eens in een byte[] array. Wel dus zelf zorgen dat de array tijdens compilen groot genoeg is voor alle data die je erin wilt lezen. En bij het sturen naar de browser ook zelf over de array loopen omdat je er dus niet vanuit mag gaan dat de sw weet waar het einde van de array is.

Ok, dus tijdens compileren dat array al laten aanmaken op 150KB dan?
En dan gewoon leeglaten totdat ik het ga vullen met data uit het bestand op SPIFFS?

Later zou je wel dynamisch een array kunnen maken met malloc() maar wees je er dan van bewust dat het geheugen niet eindig is en dat je makkelijk gatenkaas van je geheugen maakt.

Als ik dat maar op één plek in de code doe, kan het dan ook nog fout gaan?
En is het dan nog "erg" dat ik bij het uploaden van nieuwe sounddata deze weer in hetzelfde array (op dezelfde plek dus) schrijf? Dat lijkt me eigenlijk juist goed/fijn toch? (om gatenkaas tegen te gaan?!)

[CurlyMo]

Atmoz schreef op zaterdag 16 april 2022 @ 12:43:
[...]


Stel je voor dat ik bijvoorbeeld 150KB als max zou gaan accepteren (door "vooraan aan de poort" c.q. het webinterface gewoonweg niet meer te laten inladen), welke methode is dan het beste?

Hangt er vanaf of je die 150KB ooit nog vrij gaat geven of dat die 150KB altijd wel geclaimed blijft. In dat laatste geval gewoon een statische buffer.

Ik terminate inderdaad helemaal niets.

Dan weet C dus niet hoe lang je character array is.

Ik schrijf gewoon de nieuwe data over het bestaande array dat tijdens het compileren in PROGMEM wordt gezet. Als ik dat (bij kortere nieuwe data) wel zou terminaten, zou de nieuwe array dan gewoon netjes korter zijn?

Nee, het veranderd niks aan de array grootte, alleen iets aan hoe groot C je inhoud ziet.

En wat gebeurt er dan met de "rest data" die eigenlijk nog erachteraan kwam? Daar ben ik wel zéér benieuwd naar eigenlijk... Erg interessant ook!

Niks

Tja is eigenlijk, kan de ESP32 goed omgaan met zulke grote array's die tijdens runtime pas worden gedeclareerd? Dus pakweg van zo'n 150KB. Is dat goede memory-management voor aanwezig?

Er hoeft daar geen memory management voor aanwezig te zijn, want een statische buffer valt niet te managen. Die is gewoon statisch. Ik heb eerder al aangegeven dat dat afhankelijk van de context een prima aanpak kan zijn. Want als dát zo is, en het is niet gek om gewoon tijdens runtime 1 zo'n grote array aan te maken, dan is dat natuurlijk ook gewoon een (makkelijke) oplossing!

En dan gewoon leeglaten totdat ik het ga vullen met data uit het bestand op SPIFFS?

Ik zou hem leeg declareren

C:

unsigned char soundData[151] = { '\0' };

Je zou hem ook bij hergebruik ook eerst even leeg kunnen maken:

C:

memset(&soundData, 0, sizeof(soundData));

Het vergeten van deze handeling is debet aan een groot aantal beveiligingsissues in C.

Als ik dat maar op één plek in de code doe, kan het dan ook nog fout gaan?
En is het dan nog "erg" dat ik bij het uploaden van nieuwe sounddata deze weer in hetzelfde array (op dezelfde plek dus) schrijf? Dat lijkt me eigenlijk juist goed/fijn toch? (om gatenkaas tegen te gaan?!)

Dat kan prima

[Septillion]

Atmoz schreef op zaterdag 16 april 2022 @ 12:43:
Ik terminate inderdaad helemaal niets. Ik schrijf gewoon de nieuwe data over het bestaande array dat tijdens het compileren in PROGMEM wordt gezet. Als ik dat (bij kortere nieuwe data) wel zou terminaten, zou de nieuwe array dan gewoon netjes korter zijn? En wat gebeurt er dan met de "rest data" die eigenlijk nog erachteraan kwam? Daar ben ik wel zéér benieuwd naar eigenlijk... Erg interessant ook!

Termination is hier ook niet zo van belang. Dat is alleen van belang als je (ascii) C-strings gebruikt. Maar voor je Wav is dat volgens mij niet het geval. Daar staat volgens mij de grote van de data in de header van de data.

Maar of je nu het einde aangeeft met een termination char zoals ascii of aan het begin inleest hoe groot de data is, het maakt dan niet uit dat er nog data staat na de bruikbare data. Het gaat er dan gewoon op dat je werkelijk de termination of de grote van de data gebruikt tijdens het lezen om te zien dat je aan het einde bent. Het blijft ook aan jou om niet buiten de gedeclareerde ruimte te schrijven (dus voorbij de grote van de array of van de geclaimde ruimte met malloc()).

Tja is eigenlijk, kan de ESP32 goed omgaan met zulke grote array's die tijdens runtime pas worden gedeclareerd? Dus pakweg van zo'n 150KB. Is dat goede memory-management voor aanwezig? Want als dát zo is, en het is niet gek om gewoon tijdens runtime 1 zo'n grote array aan te maken, dan is dat natuurlijk ook gewoon een (makkelijke) oplossing!

ESP32 heeft volgens mij 520kB RAM. Zou zeggen dat 150kB dan geen probleem moet zijn maar dat hangt natuurlijk zwaar af van wat je nog meer doet.

Memory managment is eigenlijk niet aanwezig, vandaar dat je met grote blokken dynamische data altijd op moet letten met wat je doet. En juist dezelfde ruimte weer gebruiken is gunstig. Juist een free() doen en dan later een net grotere allocation doen dan eerst is een recept om voorn gaten in je geheugen te zorgen omdat het nu het oude gat in de RAM zal moeten overslaan omdat het daar niet meer past (als er later nog andere dingen op de heap gegooid zijn).

Ok, dus tijdens compileren dat array al laten aanmaken op 150KB dan?
En dan gewoon leeglaten totdat ik het ga vullen met data uit het bestand op SPIFFS?

Als je al weet dat je het gaat gebruiken en max 150kB is zou ik het zeker tijdens compilen al declareren. Dan kan de compiler er al rekening mee houden en neemt het mee in de "memory used". Alles wat je namelijk tijdens runtime alloceert heeft de compiler geen weet van.

Als ik dat maar op één plek in de code doe, kan het dan ook nog fout gaan?
En is het dan nog "erg" dat ik bij het uploaden van nieuwe sounddata deze weer in hetzelfde array (op dezelfde plek dus) schrijf? Dat lijkt me eigenlijk juist goed/fijn toch? (om gatenkaas tegen te gaan?!)

Ja dat is fijn. Het gaat eigenlijk vooral makkelijk mis als je veel blokken steeds alloceert en vrijgeeft of resized (eigenlijk een malloc, move, free actie). Dit is bijvoorbeeld wat de String classe aan de lopende band moet doen als je dingen aan een string toe voegt. Want als na de String al weer wat anders in geheugen staat is er dus geen ruimte voor de toevoeging en zal dus de hele string eerst naar het einde van de heap verplaatst moeten worden voor er weer wat extra ruimte achter beschikbaar is voor de toevoeging. Dit laat op de eerdere plek dus weer een gat achter. Je bent dan makkelijk een haasje over door je heap aan het doen.

[Seafarer]

ThinkPad schreef op vrijdag 16 april 2021 @ 14:26:
Ik heb 3x DS18B20 aan een Wemos D1 Mini (ESP8266) hangen en dat werkt prima met Tasmota (8.5.0). Volgens mij heb ik de weerstand weggelaten omdat de ESP zelf al een pullup weerstand ingebouwd heeft.

Voeding zorgt misschien voor issues, probeer het eerst eens met een goede betrouwbare 5V.

Kun jij iedere sensor een toewijzing geven of andere naam?

Want onderstaand, zie foto, werkt perfect totdat je een sensor verwijdert of er eentje vervangt. Tasmota verzorgt de nummering.
Normaal heb je maar een sensor en een Sonoff in Domoticz toegewezen.
Ik gebruik https://github.com/joba-1/Tasmoticz om meerdere sensoren op een Sonoff automagisch toe te wijzen in Domoticz. Of er is iets wat ik niet weet.

[ThinkPad]

Volgens mij zou ik dat issue dan ook hebben inderdaad. Maar waarom zou je sensoren loskoppelen?

[Seafarer]

ThinkPad schreef op zondag 24 april 2022 @ 17:51:
Volgens mij zou ik dat issue dan ook hebben inderdaad. Maar waarom zou je sensoren loskoppelen?

Omdat ik ze ergens anders nodig had en toen viel het me op.

Ik heb maar een regel: Alles gaat kapot. Ook het allerbeste, soms duurt dat heel erg lang maar het gaat kapot.

Dus als jij meerdere sensoren hebt dan worden ze door tasmota op dezelfde manier toegewezen als wat ik op de foto liet zien?
Hoe doe jij dat dan met Domoticz? Kun je ze daar zelf per sensor toewijzen? (als je dat gebruikt)

Edit: trek er eens eentje los?

[ Voor 3% gewijzigd door Seafarer op 24-04-2022 18:07 ]

[ThinkPad]

Ik gebruik geen Domoticz, maar Node-RED. Ik vraag via HTTP (/cm?cmnd=status 8 ) de status van de sensoren op bij Tasmota en krijg dat in een JSON-reply terug. Net even voor je gechecked en ik doe het volgende:

JavaScript:

msg.state.temperature = +(msg.payload.StatusSNS['DS18B20-3'].Temperature).toFixed(2);

Als ik sensoren ga loskoppelen dan gaat het bij mij dus ook mis. Maar heb deze setup al zeker een jaar of 3 draaien zonder issues.

Maar ik zie dat in de JSON output ook de ID van de sensor zit. Dus het is gewoon een kwestie van goed programmeren en niet hardcoded naar de naamgeving van Tasmota verwijzen, maar naar de temperatuur horend bij de ID. Weet alleen niet of dat altijd al zo geweest is, misschien is het recentelijk pas toegevoegd.

JSON:

{
  "StatusSNS": {
    "Time": "2022-04-24T18:50:24",
    "DS18B20-1": {
      "Id": "000004A81992",
      "Temperature": 20.2
    },
    "DS18B20-2": {
      "Id": "000004A8DF66",
      "Temperature": 20.2
    },
    "DS18B20-3": {
      "Id": "000004B586F3",
      "Temperature": 20.3
    },
    "TempUnit": "C"
  }
}

[ Voor 13% gewijzigd door ThinkPad op 24-04-2022 20:29 ]

[Seafarer]

ThinkPad schreef op zondag 24 april 2022 @ 18:53:
Ik gebruik geen Domoticz, maar Node-RED. Ik vraag via HTTP (/cm?cmnd=status 8 ) de status van de sensoren op bij Tasmota en krijg dat in een JSON-reply terug. Net even voor je gechecked en ik doe het volgende:

JavaScript:

msg.state.temperature = +(msg.payload.StatusSNS['DS18B20-3'].Temperature).toFixed(2);

Als ik sensoren ga loskoppelen dan gaat het bij mij dus ook mis. Maar heb deze setup al zeker een jaar of 3 draaien zonder issues.

Maar ik zie dat in de JSON output ook de ID van de sensor zit. Dus het is gewoon een kwestie van goed programmeren en niet hardcoded naar de naamgeving van Tasmota verwijzen, maar naar de temperatuur horend bij de ID. Weet alleen niet of dat altijd al zo geweest is, misschien is het recentelijk pas toegevoegd.

JSON:

{
  "StatusSNS": {
    "Time": "2022-04-24T18:50:24",
    "DS18B20-1": {
      "Id": "000004A81992",
      "Temperature": 20.2
    },
    "DS18B20-2": {
      "Id": "000004A8DF66",
      "Temperature": 20.2
    },
    "DS18B20-3": {
      "Id": "000004B586F3",
      "Temperature": 20.3
    },
    "TempUnit": "C"
  }
}

Aha zelfde issue.
Maar het is inderdaad heel betrouwbaar ik had het al twee jaar draaien zonder problemen. En het is nog steeds betrouwbaar, ik had alleen niet een sensor er tussenuit moeten halen.

[ThinkPad]

Ik heb het via Node-RED inmiddels al kunnen ombouwen: ThinkPad in "Node-RED - grafisch 'programmeren' (bijv. voor domotica)"

[Seafarer]

DjoeC schreef op zondag 10 november 2019 @ 13:57:
[...]


Dit klopt niet helemaal/helemaal niet. Begin eens hier https://www.maximintegrat...ents/tutorials/1/148.html te lezen.

Ik draai zelf > 20 1-wire DS18B20 (made in China) serieel op een mini D1 (totaal meer dan 40 op 2 stuks, 2 locaties). Het geheel draait op 5V want op 3.3V was het onbetrouwbaar.
Het grootste probleem is om alle informatie op te zoeken en te interpreteren. 1-wire is ontzettend handig maar niet alle info is op 1 plek beschikbaar.

1 wire sensoren in serie?

(ik weet het, lekker late reactie. Maar ik was alles eens aan het doorlezen )

[etienne001]

Gisteravond 2 stuks ds18b20 (de waterdichte met kabellengte van 1 meter) geïnstalleerd voor uitlezing van de
aanvoer en retour van de CV ketel.
Ik heb het geheel aangesloten op een Wemos D1 mini die is geflashed met ESP mega.
De ds18b20's worden netjes gezien (aangesloten op GPIO4 en GPIO5 met een 4K7 weerstand per sensor.
In eerste instantie leek de waarde te kloppen, later heb ik de cv even aangezet om eens te zien hoe de ds18b20's reageren. Als de aanvoer van de CV 40 graden is dan geeft de ds18b20 een temperatuur van 31 graden. De andere ds18b20 wijkt ook zo'n 10 graden af.
Ik heb de leidingen nog nagemeten met een IR meter die lijkt te kloppen met de temperatuurwaarde die de CV ketel uitgeeft.
Iemand toevallig bekend met de afwijkende temperatuur van de ds18b20 sensoren?

[BazemanKM]

etienne001 schreef op woensdag 27 april 2022 @ 22:09:
Gisteravond 2 stuks ds18b20 (de waterdichte met kabellengte van 1 meter) geïnstalleerd voor uitlezing van de
aanvoer en retour van de CV ketel.
Ik heb het geheel aangesloten op een Wemos D1 mini die is geflashed met ESP mega.
De ds18b20's worden netjes gezien (aangesloten op GPIO4 en GPIO5 met een 4K7 weerstand per sensor.
In eerste instantie leek de waarde te kloppen, later heb ik de cv even aangezet om eens te zien hoe de ds18b20's reageren. Als de aanvoer van de CV 40 graden is dan geeft de ds18b20 een temperatuur van 31 graden. De andere ds18b20 wijkt ook zo'n 10 graden af.
Ik heb de leidingen nog nagemeten met een IR meter die lijkt te kloppen met de temperatuurwaarde die de CV ketel uitgeeft.
Iemand toevallig bekend met de afwijkende temperatuur van de ds18b20 sensoren?

Voor beide sensoren kun je gebruik maken van 1 weerstand

[Andrehj]

etienne001 schreef op woensdag 27 april 2022 @ 22:09:
Gisteravond 2 stuks ds18b20 (de waterdichte met kabellengte van 1 meter) geïnstalleerd voor uitlezing van de
aanvoer en retour van de CV ketel.
Ik heb het geheel aangesloten op een Wemos D1 mini die is geflashed met ESP mega.
De ds18b20's worden netjes gezien (aangesloten op GPIO4 en GPIO5 met een 4K7 weerstand per sensor.
In eerste instantie leek de waarde te kloppen, later heb ik de cv even aangezet om eens te zien hoe de ds18b20's reageren. Als de aanvoer van de CV 40 graden is dan geeft de ds18b20 een temperatuur van 31 graden. De andere ds18b20 wijkt ook zo'n 10 graden af.
Ik heb de leidingen nog nagemeten met een IR meter die lijkt te kloppen met de temperatuurwaarde die de CV ketel uitgeeft.
Iemand toevallig bekend met de afwijkende temperatuur van de ds18b20 sensoren?

Wat geven de sensoren aan in kokend water en in ijswater?
En heb je de sensoren wel thermisch goed geleidend met de leidingen verbonden? En van de omgevingslucht geïsoleerd?

[ Voor 5% gewijzigd door Andrehj op 27-04-2022 22:22 ]

[Seafarer]

etienne001 schreef op woensdag 27 april 2022 @ 22:09:
Gisteravond 2 stuks ds18b20 (de waterdichte met kabellengte van 1 meter) geïnstalleerd voor uitlezing van de
aanvoer en retour van de CV ketel.
Ik heb het geheel aangesloten op een Wemos D1 mini die is geflashed met ESP mega.
De ds18b20's worden netjes gezien (aangesloten op GPIO4 en GPIO5 met een 4K7 weerstand per sensor.
In eerste instantie leek de waarde te kloppen, later heb ik de cv even aangezet om eens te zien hoe de ds18b20's reageren. Als de aanvoer van de CV 40 graden is dan geeft de ds18b20 een temperatuur van 31 graden. De andere ds18b20 wijkt ook zo'n 10 graden af.
Ik heb de leidingen nog nagemeten met een IR meter die lijkt te kloppen met de temperatuurwaarde die de CV ketel uitgeeft.
Iemand toevallig bekend met de afwijkende temperatuur van de ds18b20 sensoren?

Hoe heb je ze op de pijp gemonteerd?

[etienne001]

BazemanKM schreef op woensdag 27 april 2022 @ 22:15:
[...]

Voor beide sensoren kun je gebruik maken van 1 weerstand

Dan kan ik ze dus beide aansluiten op één ingang? Maakt het nog uit welke ingang ik hiervoor gebruik?
Zouden 2 weerstanden dan teveel vragen van het boardje?

Andrehj schreef op woensdag 27 april 2022 @ 22:20:
[...]

Wat geven de sensoren aan in kokend water en in ijswater?

Dat is een goede vraag, niet getest eerlijk gezegd...
Ga ik eens proberen.
Edit:
Kokend water:
Digitale vlees thermometer 93.7 graden
Analoge thermometer ca 93 graden
IR thermometer 93.5 graden
ds18b20 93.3 graden en 93.5

Koud water:
Digitale vlees thermometer 4.2 graden
Analoge thermometer ca 4 graden
IR thermometer 4.3 graden
ds18b20 3.9 graden en 3.8

Dit lijkt dus wel te kloppen, al moet ik zeggen dat de ds18b20's er ongeveer een minuut over doen deze waardes te bereiken. Interval in de Wemos staat op 5 seconde op t ogenblik.

Seafarer schreef op woensdag 27 april 2022 @ 22:22:
[...]

Hoe heb je ze op de pijp gemonteerd?

Helemaal ingetaped met isolatietape.
Ik zal morgen bij de bouwmarkt even een lengte buis isolatie halen en beide ook nog eens inpakken in de isolatie. Wellicht dat dit nog wat meer helpt.

[ Voor 41% gewijzigd door etienne001 op 27-04-2022 23:04 ]

[Raymond P]

Als je met waterdicht de units bedoelt met een pennendop erop en een krimpkousje erover: ja, je bent afhankelijk van de thermische geleiding en vulling van dat dopje.
Vaak niet fantastisch, een losse unit presteert beter.

[Seafarer]

etienne001 schreef op woensdag 27 april 2022 @ 22:23:
[...]


Helemaal ingetaped met isolatietape.
Ik zal morgen bij de bouwmarkt even een lengte buis isolatie halen en beide ook nog eens inpakken in de isolatie. Wellicht dat dit nog wat meer helpt.

Als ik mag adviseren, op bovenzijde pijp monteren en dan met 2 sterke kabelbinders heel erg strak er tegen aan trekken.
Desnoods warmtegeleidings pasta ertussen.

[Atmoz]

Wie kan mij helpen met het volgende probleem?

In een bepaalde situatie wil ik mijn ESP32 in deep sleep zetten en middels de ULP een IR-sensor uitlezen die aan een analoge ingang hangt.

Ik heb daarvoor de volgende code gevonden en iets aangepast:

code:

void ulp_adc_wake_up(unsigned int low_adc_treshold, unsigned int high_adc_treshold)
{
   adc1_config_channel_atten(ADC1_CHANNEL_4, ADC_ATTEN_DB_11);  // (was eerst ADC1_CHANNEL_0, ADC_ATTEN_DB_11);)
   adc1_config_width(ADC_WIDTH_BIT_10);
   adc1_ulp_enable();

   rtc_gpio_init(GPIO_NUM_32); // de analoge poort waar de IR-sensor aan hangt (was 36 in het voorbeeld)
   
   gpio_hold_en(GPIO_NUM_13); //pcb power

   gpio_deep_sleep_hold_en(); //pcb power moet hoog blijven 
   

   const ulp_insn_t program[] = {
      I_DELAY(32000),              // Wait until ESP32 goes to deep sleep
      M_LABEL(1),                  // LABEL 1
        I_MOVI(R0, 0),             // Set reg. R0 to initial 0
        I_MOVI(R2, 0),             // Set reg. R2 to initial 0
      M_LABEL(2),                  // LABEL 2
        I_ADDI(R0, R0, 1),         // Increment cycle counter (reg. R0)
        I_ADC(R1, 0, 0),           // Read ADC value to reg. R1
        I_ADDR(R2, R2, R1),        // Add ADC value from reg R1 to reg. R2
      M_BL(2, 4),                  // If cycle counter is less than 4, go to LABEL 2
      I_RSHI(R0, R2, 2),           // Divide accumulated ADC value in reg. R2 by 4 and save it to reg. R0
      M_BGE(3, high_adc_treshold), // If average ADC value from reg. R0 is higher or equal than high_adc_treshold, go to LABEL 3
      M_BL(3, low_adc_treshold),   // If average ADC value from reg. R0 is lower than low_adc_treshold, go to LABEL 3
      M_BX(1),                     // Go to LABEL 1
      M_LABEL(3),                  // LABEL 3
      I_WAKE(),                    // Wake up ESP32
      I_END(),                     // Stop ULP program timer
      I_HALT()                     // Halt the coprocessor
   };

   size_t size = sizeof(program)/sizeof(ulp_insn_t);
   ulp_process_macros_and_load(0, program, &size);

   ulp_run(0);
   
   esp_sleep_enable_ulp_wakeup();
   esp_deep_sleep_start();
}

Ik roep dit vervolgens aan met:

code:

ulp_adc_wake_up(225,1023);

De ESP gaat na deze aanroep inderdaad in slaapmodus, maar ik krijg hem met geen mogelijkheid meer wakker...
Ook niet als ik met die waardes (225 en 1023) speel.

Doe ik nog iets fout? Want ik heb een kleine wijziging moeten doen:

Bovenaan stond eerst: adc1_config_channel_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_11); (ik heb er ADC1_CHANNEL_4 van gemaakt omdat de IO pin die ik gebruik (IO32) op channel 4 hangt van ADC1)
En even verderop stond: rtc_gpio_init(GPIO_NUM_36); (ik gebruik IO32)

Is er nog iets anders dat ik ben vergeten? Het voorbeeld komt van hier en lijkt te werken.

Iemand?

[zierbeek]

heeft iemand toevallig een werkende config voor de mqtt broker op de esphome naar thingspeak?

[I-King]

Een beetje vreemd geval, maar ik wil de temperatuursensor van de airco beïnvloeden. Nu had ik de tip gekregen er een 5K potmeter tussen te hangen om zo de offset te beïnvloeden.
Echter, nog mooier om dat digitaal te doen, maar kan dat? Is er een component (of evt al standaardmogelijkheid) om hier iets mee te doen? 0 tot 5K Ohm is voldoende.

Ik heb nog geen ESP kennis, dus moet me sowieso inlezen, maar als iemand me een zetje in de juiste richting wil geven zou meer dan welkom zijn!

[Raymond P]

@I-King Je bedoelt een digitale pot(entio)meter?

[I-King]

@Raymond P Yes, zo simpel zal het zijn Ik weet niet meer waar ik dan gisteren op gezocht heb, maar heb nu iig een paar topics gevonden die in deze richting schijnen: https://community.home-as...istant-via-esphome/142704

Wellicht kom ik daar al een eindje mee, sowieso een leuke praktische introductie in esphome, een hoek die ik toch wel eens wilde gaan bekijken.

Mocht iemand concrete(re) tips hebben, hoor ik het graag.

[Raymond P]

Als je met Arduino aan de slag wilt gaan: https://electropeak.com/l...eter-module-with-arduino/
Hass en esphome heb ik geen ervaring mee.

Er zijn iig wel een aantal breakout boards en libraries beschikbaar.

[Atmoz]

Ik kom graag nog even terug op mijn laatste vraag (over ULP).

Met een snelle zoekfunctie (in dit topic) kwam ik erachter dat er hier maar zéér weinig gesproken wordt over dat prachtige ULP. Zonde, want volgens mij is het echt iets heel moois (als je het werkend krijgt )

Een bericht van 3 jaar geleden, maar hopelijk helpt het:

Vuikie schreef op maandag 1 april 2019 @ 13:05:
YAY! Ik heb de ULP in de ESP32 in de Arduino omgeving werkend gekregen.
Best wel een krachtig dingetje, die ULP. Hij kan I2C, ADC en de interne temperatuur sensor uitlezen. Maar het mooiste is dat ie de hele chip wakker kan maken. Dus hij kan als een soort 'watch-dog' fungeren. Gewoon de hele chip in deepsleep gooien, de ULP elk xxxms, via een wake-up-timer, een meting laten doen en, indien nodig, de chip wakker maken. Of gewoon verder slapen
Maar omdat ie op 150Khz(Ja dit lees je goed!) loopt, dankt ie zijn naam 'Ultra Low Power coprocessor' daar aan. Het nadeel is wel dat ie momenteel alleen in assembler geprogrammeerd kan worden, maar als je de ESP32 op batterijen wil laten lopen, is het leren werken met deze ULP coprocessor een must.(Naar mijn mening)

Heb jij uiteindelijk ook de ADC uitlezen in ULP werkend gekregen?
En verder had ik nog een vraag over deze regel:

de ULP elk xxxms, via een wake-up-timer, een meting laten doen en, indien nodig, de chip wakker maken

Ik lees het zo dat je zelfs de ULP in sleep laat gaan, klopt dat? En zoja; is dat in mijn situatie ook handig om te doen, of juist niet?
Want ik zou graag zo vaak als maar kan de ADC uitlezen zodat de kans het grootste is dat de detectie (middels de IR-sensor) goed gaat.

Ben erg benieuwd of jij (of iemand anders hier ) dit (ADC uitlezen in ULP) wél werkend hebt gekregen

[Vuikie]

@Atmoz Ik heb nog niet gewerkt met de ADC in ULP. Dat zou wel moeten kunnen wat ik zo in de documentatie lees, maar wel alleen van ADC1. ADC2 is alleen bereikbaar vanaf CPU0 of CPU1, van wat ik zo snel begrijp.

De ULP ondersteund ook JUMP-instructies dus je hoeft hem niet met een HALT-instructie te stoppen en weer te wekken met de RTC-timer, maar gewoon continue de ADC uit blijven lezen.

Het ADC-verhaal is wel interessant. Ga ik wel een keer mee spelen wanneer ik tijd heb.

[DjoeC]

Seafarer schreef op woensdag 27 april 2022 @ 16:40:
[...]

1 wire sensoren in serie?

(ik weet het, lekker late reactie. Maar ik was alles eens aan het doorlezen )

Tja, je hebt natuurlijk gelijk: parallel aan 3 draadjes (plus, min & data). Het maximale aantal dat bij mij werkte was 100 stuks.

[Seafarer]

DjoeC schreef op dinsdag 3 mei 2022 @ 10:57:
[...]

Tja, je hebt natuurlijk gelijk: parallel aan 3 draadjes (plus, min & data). Het maximale aantal dat bij mij werkte was 100 stuks.

Okay type faut.

Jij hebt dus regelmatig sensors in een ster staan zonder problemen
Edit: ik heb ook meerdere op een sonoff th10 met Tasmota en dat gaat soms fout. Sensor kabels ongeveer 3 mtr.
Extra pull up plaatsen zou een oplossing kunnen zijn?

[ Voor 19% gewijzigd door Seafarer op 03-05-2022 12:41 ]

[Atmoz]

Vuikie schreef op dinsdag 3 mei 2022 @ 09:47:
@Atmoz Ik heb nog niet gewerkt met de ADC in ULP. Dat zou wel moeten kunnen wat ik zo in de documentatie lees, maar wel alleen van ADC1. ADC2 is alleen bereikbaar vanaf CPU0 of CPU1, van wat ik zo snel begrijp.

Ja klopt, maar ik gebruik ook ADC1

De ULP ondersteund ook JUMP-instructies dus je hoeft hem niet met een HALT-instructie te stoppen en weer te wekken met de RTC-timer, maar gewoon continue de ADC uit blijven lezen.

Ok, en betekend dit dat hij dan in feite in een loop blijft TOTDAT er iets (een sensor geeft een bepaalde waarde) gebeurt wat hem uit deze lus haalt en vervolgens de main-core wakker maakt?

Waar zit dit loop dan precies?

Want ik krijg zojuist dit doorgestuurd van iemand op Upwork die ik betaald heb:

code:

#include <WiFi.h> // This is the most basic WiFi implimentation
#include "esp32/ulp.h"
#include "driver/adc.h"         
#include <esp_bt.h>             
#include <esp_wifi.h>           
#include "soc/rtc_cntl_reg.h"
#include "driver/rtc_io.h"
#define uS_TO_S_FACTOR 1000000  
#define TIME_TO_SLEEP  300

void power_off(){
  setCpuFrequencyMhz(80); //Save power by stepping down CPU freq. NOTE: Test this, as it can affect some sensor reading
  btStop();               // Power down BT for best power saving
  esp_wifi_stop();        // Power down the Wifi radios for best power saving
  esp_deep_sleep_start(); 
  }
  
void ulp_adc_wake_up(unsigned int low_adc_treshold, unsigned int high_adc_treshold)
{
   adc1_config_channel_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_11);
   adc1_config_width(ADC_WIDTH_BIT_10);
   adc1_ulp_enable();

   rtc_gpio_init(GPIO_NUM_36);

   const ulp_insn_t program[] = {
      I_DELAY(32000),              // Wait until ESP32 goes to deep sleep
      M_LABEL(1),                  // LABEL 1
        I_MOVI(R0, 0),             // Set reg. R0 to initial 0
        I_MOVI(R2, 0),             // Set reg. R2 to initial 0
      M_LABEL(2),                  // LABEL 2
        I_ADDI(R0, R0, 1),         // Increment cycle counter (reg. R0)
        I_ADC(R1, 0, 0),           // Read ADC value to reg. R1
        I_ADDR(R2, R2, R1),        // Add ADC value from reg R1 to reg. R2
      M_BL(2, 4),                  // If cycle counter is less than 4, go to LABEL 2
      I_RSHI(R0, R2, 2),           // Divide accumulated ADC value in reg. R2 by 4 and save it to reg. R0
      M_BGE(3, high_adc_treshold), // If average ADC value from reg. R0 is higher or equal than high_adc_treshold, go to LABEL 3
      M_BL(3, low_adc_treshold),   // If average ADC value from reg. R0 is lower than low_adc_treshold, go to LABEL 3
      M_BX(1),                     // Go to LABEL 1
      M_LABEL(3),                  // LABEL 3
      I_WAKE(),                    // Wake up ESP32
      I_END(),                     // Stop ULP program timer
      I_HALT()                     // Halt the coprocessor
   };

   size_t size = sizeof(program)/sizeof(ulp_insn_t);
   ulp_process_macros_and_load(0, program, &size);

   ulp_run(0);
   esp_sleep_enable_ulp_wakeup();
   btStart();
   esp_wifi_start();
}


void setup() {

    
  Serial.begin(115200);
  adc_power_on();    
  power_off();
 
 
}

void loop()
{
  ulp_adc_wake_up(0, 3500);
}

Deze code is sowieso niet helemaal goed, want hij heeft zich in de IO-pin vergist Maar buiten dat: klopt dit zo?

code:

void loop()
{
  ulp_adc_wake_up(0, 3500);
}

Moet "ulp_adc_wake_up(0, 3500);" constant in de main-loop worden uitgevoerd?

[DjoeC]

Seafarer schreef op dinsdag 3 mei 2022 @ 11:25:
[...]

Okay type faut.

Jij hebt dus regelmatig sensors in een ster staan zonder problemen
Edit: ik heb ook meerdere op een sonoff th10 met Tasmota en dat gaat soms fout. Sensor kabels ongeveer 3 mtr.
Extra pull up plaatsen zou een oplossing kunnen zijn?

Nee, ster is het ook niet echt vanwege de korte afstand:
Groene blokje is een 2.54mm PCB connector. De sensor zit aan de PCB pootjes en is dus eigenlijk de sterkant, isolatietape om sluiting voor te zijn. In de connector zit 2x CAT6 als de serieele kant (doorgelust), hoe zuiverder de twists ofwel hoe korter de kabels naar de connector, hoe minder interferentie en stabieler de signalen. Dus:heel korte stervormige uitsteeksels aan een serieele kabel. Elke sensor zit ~40cm van de voorgaande behalve de laatste paar die zitten op ~80-100cm. Totale lengte is met 21 sensoren 8-10m, gaat al jaren goed

3 draads aansluiting, fantoomvoeding - 2 draads - gaat volgens internet vaak niet goed. 5V gebruiken indien mogelijk. Afsluitweerstand is bij mij (ik meen) ~1K5 of ~1K geworden. Beetje stoeien tot het stabiel werkt. Nogmaals: twisted en de juiste draadkleuren gebruiken, oranje = plus, blauw-wit = min, blauw = data. Ook dat ergens op internet gevonden, Hier is een referentie (niet nagelezen).

Het probleem zit waarschijnlijk in de timing van de signalen. Hoe groter de afstanden tot de serieele (centrale) draad worden, hoe meer kans op verstoringen doordat je datasignaal alle kanten opgaat en weer terugkaatst. Sensoren op 3m van je hoofdleiding is vermoedelijk te ver. Ik neem aan dat je dit document van Maxim al eens hebt gelezen? Er zijn nog een aantal internet beschrijvingen, lees en combineer de informatie....

Mijn 100 stuks was een test op (meerdere) breadboards om de sensoren te calibreren tov elkaar, jumperkabels van 10-20cm naar de dataline, sensoren waren toen nog 15ct/stuk, nu trouwens ook maar 17ct bij 50 stuks.... NB: Nogmaals: geen fantoomvoeding dus, dat wordt afgeraden, werkte bij mij met meer sensoren ook al snel niet meer.

Ik gebruik de discoverfunctie om de ID's binnen te halen, daarna worden ze stuk voor stuk uitgelezen, data staat klaar om opgehaald te worden, de sensoren zenden niet zelf om te voorkomen dat er meerdere gelijk data gaan sturen. Zorg voor zo min mogelijk gelijktijdig verkeer, 1 device gelijk als mogelijk.

Uiteraard kun je meerdere 1-wire pinnen op een ESP gebruiken. Daarnaast zijn er busmaster chips zoals de DS2484-800 die je kunt gebruiken om wel een ster netwerk te maken.... Ik heb er 2 van Aliexpress gehaald met SOIC voetje naar DIP adapter. Nog niet in gebruik want het werkt nu toch al.

[Seafarer]

Dank voor je uitgebreide post.

DjoeC schreef op dinsdag 3 mei 2022 @ 15:49:
[...]

Nee, ster is het ook niet echt vanwege de korte afstand: [Afbeelding]
Groene blokje is een 2.54mm PCB connector. De sensor zit aan de PCB pootjes en is dus eigenlijk de sterkant, isolatietape om sluiting voor te zijn. In de connector zit 2x CAT6 als de serieele kant (doorgelust), hoe zuiverder de twists ofwel hoe korter de kabels naar de connector, hoe minder interferentie en stabieler de signalen. Dus:heel korte stervormige uitsteeksels aan een serieele kabel. Elke sensor zit ~40cm van de voorgaande behalve de laatste paar die zitten op ~80-100cm. Totale lengte is met 21 sensoren 8-10m, gaat al jaren goed

3 draads aansluiting, fantoomvoeding - 2 draads - gaat volgens internet vaak niet goed. 5V gebruiken indien mogelijk. Afsluitweerstand is bij mij (ik meen) ~1K5 of ~1K geworden. Beetje stoeien tot het stabiel werkt. Nogmaals: twisted en de juiste draadkleuren gebruiken, oranje = plus, blauw-wit = min, blauw = data. Ook dat ergens op internet gevonden, Hier is een referentie (niet nagelezen).

Het probleem zit waarschijnlijk in de timing van de signalen. Hoe groter de afstanden tot de serieele (centrale) draad worden, hoe meer kans op verstoringen doordat je datasignaal alle kanten opgaat en weer terugkaatst. Sensoren op 3m van je hoofdleiding is vermoedelijk te ver. Ik neem aan dat je dit document van Maxim al eens hebt gelezen? Er zijn nog een aantal internet beschrijvingen, lees en combineer de informatie....

Mijn 100 stuks was een test op (meerdere) breadboards om de sensoren te calibreren tov elkaar, jumperkabels van 10-20cm naar de dataline, sensoren waren toen nog 15ct/stuk, nu trouwens ook maar 17ct bij 50 stuks.... NB: Nogmaals: geen fantoomvoeding dus, dat wordt afgeraden, werkte bij mij met meer sensoren ook al snel niet meer.

Ik gebruik de discoverfunctie om de ID's binnen te halen, daarna worden ze stuk voor stuk uitgelezen, data staat klaar om opgehaald te worden, de sensoren zenden niet zelf om te voorkomen dat er meerdere gelijk data gaan sturen. Zorg voor zo min mogelijk gelijktijdig verkeer, 1 device gelijk als mogelijk.

Dat heb ik dus niet. Gewoon op een Sonoff TH10 met Tasmota en ze lullen allemaal door elkaar waarschijnlijk. Overigens gaat dat goed met 8 sensoren en allemaal ongeveer dezelfde kabel lengte.(2 jaar)

Uiteraard kun je meerdere 1-wire pinnen op een ESP gebruiken. Daarnaast zijn er busmaster chips zoals de DS2484-800 die je kunt gebruiken om wel een ster netwerk te maken.... Ik heb er 2 van Aliexpress gehaald met SOIC voetje naar DIP adapter. Nog niet in gebruik want het werkt nu toch al.

Ik ga eens wat beter op die ene sensor letten.Die zit op een meeraderige kabel. Maar niet echt UTP. Ik zal jouw advies eens opvolgen. En eens experimenteren met een extra pull-up weerstand.

[DjoeC]

Seafarer schreef op dinsdag 3 mei 2022 @ 16:59:

Ik ga eens wat beter op die ene sensor letten.Die zit op een meeraderige kabel. Maar niet echt UTP. Ik zal jouw advies eens opvolgen. En eens experimenteren met een extra pull-up weerstand.

Lees vooral dit document van Maxim eens door en laat het bezinken....

[Atmoz]

Atmoz schreef op dinsdag 3 mei 2022 @ 14:13:

Moet "ulp_adc_wake_up(0, 3500);" constant in de main-loop worden uitgevoerd?

Ah, ik krijg op een ander forum te horen dat dit zeker NIET de bedoeling is
Lekker om mensen te betalen voor een stukje code en dan iets krijgen wat totaal niet gaat werken

Hmzzz, zo kom ik niet verder

Zijn er nog andere dingen die ik kan proberen? Weet iemand hier daar iets op te zeggen?
Je zou zeggen dat dit niet zo héél moeilijk moet zijn eigenlijk he... Zeker niet voor de doorgewinterde ESP32 programmeurs hier

Alle hulp is van harte welkom

[CurlyMo]

@Atmoz Waarom pak je analoge IR sensor en geen digitale?

[Atmoz]

@CurlyMo Dat is omdat ik met die analoge waardes niet alleen het object kan detecteren, maar ook (in beperkte mate) de kleur.

Ik had je laatst nog een PM gestuurd met bedankje enzo erin + wat verdere uitleg waarin ik ook vertelde dat ik al 1000 printplaten hier heb liggen Dus "zomaar" een andere sensor gebruiken is sowieso niet meer mogelijk

[chaoscontrol]

Atmoz schreef op donderdag 5 mei 2022 @ 08:00:
[...]

Lekker om mensen te betalen voor een stukje code en dan iets krijgen wat totaal niet gaat werken

Moet je dan niet even terug naar je programmeur?

[Atmoz]

chaoscontrol schreef op donderdag 5 mei 2022 @ 11:42:
[...]

Moet je dan niet even terug naar je programmeur?

Dat zou het meest logische zijn ja Maarja, het is via Upwork, en ik heb er maar zeer weinig voor betaald. Dus eigenlijk achteraf misschien een beetje mijn eigen schuld c.q. een "if you pay peanuts, you get monkeys" verhaal.

Al heb ik wél netjes van te voren uitgelegd (en nogmaals gevraagd of hij dit kon voordat hij akkoord ging) wat ik precies wilde...

Lastig verhaal dus... Hij is er ook nog mee bezig, maar ik krijg steeds meer het idee dat hij het echt niet kan/snapt helaas.
Hij komt uit Pakistan en helaas is de communicatie ook niet super goed.

[RobertMe]

Ik heb deze L298N motor driver, aangesloten op een ESP32, maar krijg deze helaas niet aan de praat en ben op zoek naar mogelijke hints. Uiteraard begonnen met een stukje code dat 1 GPIO pin hoog zet (en ander laag, for that matter) en aangesloten op de IN1 en IN2 poorten. Daarnaast een (universele, op 12V ingestelde) adapter aangesloten op de 12V & ground terminals. Ik zou dan dus verwachten dat ik op de "Output A" terminals met de multimeter 12V moet meten, maar dit is (uiteraard) niet het geval. Met de multimeter meet ik wel netjes 12V over de input terminals (voorzien door de adapter dus). Over de 5V output en ground meet ik ook 5V. De jumper voor "enabled" zit ook er op (continu 5V op de enable pin, i.p.v. dus een PWM signaal vanaf de ESP voorzien), en ook daar meet ik 5V overheen. Meet ik tussen het soldeerpunt (onderkant PCB) van de de IN1 pin en de ground van de ESP meet ik ook netjes 3.3V. Dus naar mijn idee klopt het allemaal in zoverre. Enige wat ik mij verder nog kan indenken is dat de logica 5V verwacht, en dit staat ook op de AliExpress pagina vermeld zie ik nu pas (vele andere voorbeelden sluiten deze module rechtstreeks op een ESP aan, dus of dat nu afwijkende PCBs zijn met dan dezelfde "chip" of dat AliExpress niet klopt is de vraag). Daarom heb ik als test de IN1 direct op de 5V output van de ESP aangesloten, maar ook dan "gebeurd er niks" (dus geen 12V over output A).

Wie zou mij dus kunnen helpen dit te debuggen / heeft nog wat hints waar te zoeken?

[Raymond P]

@Atmoz Krijg je hem wel uit deep sleep op een digital I/O?

@RobertMe Je ESP voed je niet vanaf de 5V output op de L298N? Heb je dan wel een common ground gelegd?

[RobertMe]

Raymond P schreef op donderdag 5 mei 2022 @ 23:01:
@RobertMe Je ESP voed je niet vanaf de 5V output op de L298N? Heb je dan wel een common ground gelegd?

De ESP wordt via USB gevoed (wel zo makkelijk met flashen ). Wat is hier dan het makkelijkste in? Want volgens mij zijn er ook nog wat dingetjes met dat voeden via de 5V pin en daarnaast via USB aansluiten nogal wat problemen kan geven? (dat stroom via de USB poort naar PC gaat) Alhoewel ik natuurlijk ook de 5V & ground pins van de USB connector kan afplakken, dat zou ik sowieso veilig moeten zitten.

[Raymond P]

Je zult ook common ground met de pc moeten leggen als je communicatie wilt.

Wat is handig? Een multi-line labvoeding? Serial over Wifi debug, wifi flashen?
Optocouplers etc? Zo veel opties.

Gewoon de ground van die 12V voeding doorlussen naar je ESP kan ook. (En de +5V vanaf de pc blijven halen)

Edit, lees je dus even in op common ground en waarom dat nodig is. (Ik voel mij niet gekwalificeerd om dat uit te leggen)

[ Voor 22% gewijzigd door Raymond P op 06-05-2022 09:15 . Reden: typo ]

[Septillion]

@RobertMe Welke ESP module heb je? Zijn er aardig wat die een diode in lijn hebben met de 5V van USB. Dan is het geen issue om USB + externe voeding tegelijk te hebben. Maar inderdaad altijd een common ground maken als je twee voedingen wilt gebruiken (tenzij je dat expliciet gescheiden wilt houden en weet wat je doet )

[Atmoz]

Raymond P schreef op donderdag 5 mei 2022 @ 23:01:
@Atmoz Krijg je hem wel uit deep sleep op een digital I/O?

Ja, daarmee (met een drukknopje op IO14) krijg ik hem wel uit sleep
Maar in dat geval maak ik geen gebruik van "speciale" (assembly) ULP-code.
Dus dat is denk ik niet goed vergelijken...

Ik heb daar trouwens wel weer een ander probleem: de eerste keer dat ik hem met de drukknop uit sleep haal krijg ik dit als reden:

Wakeup was not caused by deep sleep

Alle volgende keren komt dit als reden:

Wakeup caused by external signal using RTC_CNTL

En eigenlijk is dat ook een beetje gek, want ik zou verwachten dat dit komt:

Wakeup caused by external signal using RTC_IO

Toch?

[Raymond P]

@Atmoz Is het een optie om IO14 parasitair mee te laten liften op dezelfde pinout van je sensor voor de wake-up om daarna analoog uit te lezen?

Na een flash altijd even een cold boot doen, dat skippen is mogelijk de oorzaak van de melding die je niet verwacht.

[Atmoz]

Raymond P schreef op vrijdag 6 mei 2022 @ 12:54:
@Atmoz Is het een optie om IO14 parasitair mee te laten liften op dezelfde pinout van je sensor voor de wake-up om daarna analoog uit te lezen?

Ik snap niet precies wat je bedoeld, maar ik ben wel zeer benieuwd wat er dan voor zou zorgen dat het wel gaat werken? We hebben het nog steeds over het wake-uppen van de main processor als de ULP via ADC een "trigger" (van de sensor die een object "ziet") krijgt, toch?

Na een flash altijd even een cold boot doen, dat skippen is mogelijk de oorzaak van de melding die je niet verwacht.

Ah, super cool! Dat is het inderdaad
Heel erg bedankt hiervoor. Ik was alweer bang dat ik dit weer helemaal moest gaan uitzoeken

[Raymond P]

Een transistor in serie op ADC die die I/O14 hoog trekt als er iets gemeten wordt. ULP krijgt de trigger van I/O14 (want dat krijg je wel werkend).

Geen idee wat de voltage drop zou zijn, maar vast niet veel en daar kan je ongetwijfeld mee rekenen.

[Atmoz]

Raymond P schreef op vrijdag 6 mei 2022 @ 13:14:
Een transistor in serie op ADC die die I/O14 hoog trekt als er iets gemeten wordt. ULP krijgt de trigger van I/O14 (want dat krijg je wel werkend).

Geen idee wat de voltage drop zou zijn, maar vast niet veel en daar kan je ongetwijfeld mee rekenen.

Ahzo, nee dat is helaas niet meer mogelijk. Ik kan geen hardware aanpassingen meer doen.

Maar het zou anderzijds toch ook gewoon moeten kunnen met de huidige hardware?
Het is gewoon mogelijk om met de ULP/assembly de ADC uit te lezen, dus ik hoop eigenlijk stiekem dat ik dát gewoon alsnog werkend krijg

Ik heb ook het idee dat ik al heel ver ben... alleen dat laatste stukje nog even

[Raymond P]

Ik heb geen ervaring met het ultra low power gedeelte. Althans niet met de ESP32. Ik heb wel nog een wemos ESP32-S2 liggen...
Welke ESP32 heb je exact? Betreft het een chip of een 'dev-module'?

Als je daadwerkelijk al 1000 pcb's hebt liggen en nog geen werkend prototype dan heb je ergens een steekje laten vallen.

[RobertMe]

@Raymond P en @Septillion dank voor de hint naar common ground. Ik heb me gepoogd een beetje in te lezen (leuke zoekterm, ik ben niet aan het bemiddelen in een conflict ) en het probleem is mij nu helder. Voltage is het verschil tussen "de + en de -". En doordat de "-" een ander is dan die van de "+" loopt er dus geen stroom. Nu dan nog komende dagen even puzzelen naar hoe ik voor een gedeelde / gezamenlijke gnd kan zorgen. Ik zou dan in ieder geval moeten kunnen testen met de ESP aan de 5V output van de L298N module. Dan kan ik niet de ESP via USB aansluiten (en indien wel, zal USB het niet doen want daar loopt de grounding over de data pins dan inderdaad scheef), maar kan ik in ieder geval als het goed is wel de 12V over de output zien.

Septillion schreef op vrijdag 6 mei 2022 @ 10:56:
@RobertMe Welke ESP module heb je?

Het gaat om een ESP32 devkitc v4. Maar ik heb zo'n vermoeden dat het gebruik van USB in combinatie de 5V input dus sowieso niet gaat werken intussen, correct? Als die diode er al tussen zit dan is het nog maar de vraag welke ground "gebruikt wordt"? En als dat die van USB zou zijn dan werkt de aansturing van de L298N niet en als het die richting de L298N is dan werkt het USB data signaal niet, als ik het goed begrijp?

Edit:

Raymond P schreef op donderdag 5 mei 2022 @ 23:25:
Gewoon de ground van die 12V voeding doorlussen naar je ESP kan ook. (En de +5V vanaf de pc blijven halen)

Volgens mij gisteravond niet goed opgelet, of je hebt dit er later in geëdit . Begrijp ik goed dat ik dan ook werkende USB (/serial) kan hebben door de "USB ground" te onderbreken (bv afplakken in connector), en de ground vanaf de ESP naar de L298N te leggen? (ook in de ground terminal draaien dus). Want mijn interpretatie was eerder dus dat dat niet gaat werken. Dus nu weet ik niet of je USB puur wilt gebruiken / aangeeft voor de +5 of ook voor de data / serial interface.

[ Voor 21% gewijzigd door RobertMe op 06-05-2022 16:03 ]

[Raymond P]

@RobertMe Dat was inderdaad een ninja-edit.

De ground van alle verschillende voedingen met elkaar verbinden is een normale procedure.
Als er een diode tussen zit zal er geen +5V vloeien vanuit je ESP (of in dit geval L298N) naar je PC maar wel vanuit je PC naar ESP. (uiteraard afhankelijk van de polariteit van de diode).

Als je de ground naar PC knipt/afplakt dan kan je ESP op de seriele interface dus geen hoog/laag waarnemen, er is geen ring waardoor het stroompje kan vloeien.

Als je jezelf heerlijk wilt verwarren dan gaan ze er hier ietswat dieper op in: https://forum.arduino.cc/...d-why-you-need-one/626215

---

Als je daar minder zin in hebt: gewoon een jumper cable van die 12V ground schroefterminal naar een ground pin op je ESP. Dan kan je daarna USB aangesloten houden.

[ Voor 11% gewijzigd door Raymond P op 06-05-2022 16:23 ]

[Atmoz]

Raymond P schreef op vrijdag 6 mei 2022 @ 15:22:
Ik heb geen ervaring met het ultra low power gedeelte. Althans niet met de ESP32. Ik heb wel nog een wemos ESP32-S2 liggen...
Welke ESP32 heb je exact? Betreft het een chip of een 'dev-module'?

Het betreft een ESP32-WROOM-32E (16MB) die dus op een "custom made" printplaat zit.

Als je daadwerkelijk al 1000 pcb's hebt liggen en nog geen werkend prototype dan heb je ergens een steekje laten vallen.

Ja en nee

Ja: ik heb zéker wat steken laten vallen her en der, maar het is dan ook een extreem groot project.
Nee: het maakt niet zoveel uit, dit is een nice to have.
Het gewone "sleepen" werkt perfect, en alleen dát was een must.

[RobertMe]

Raymond P schreef op vrijdag 6 mei 2022 @ 16:17:
Als je daar minder zin in hebt: gewoon een jumper cable van die 12V ground schroefterminal naar een ground pin op je ESP. Dan kan je daarna USB aangesloten houden.

En dan neem ik aan de ground terminal niet meer op de adapter aansluiten? Omdat de ground dan via terminal => ESP => PC => stopcontact loopt?

Edit:
Maar de 12V loopt dan wel weer via andere route natuurlijk. Dus werkt dat dan wel? Zonder ground via die adapter.

[ Voor 12% gewijzigd door RobertMe op 06-05-2022 16:30 ]

[Raymond P]

@RobertMe Nee. Je verbind dus de ground van de 12V adapter aan de ground van je PC voeding, via de ESP, via USB.
Als je de ground van de adapter weg zou laten dan zou die 12V lijn dus helemaal niet 'lopen'.

@Atmoz Hmm duidelijk. De S2 heeft een ander type coprocessor, maar de flow zal ongetwijfeld hetzelfde zijn. Als ik tijd over heb dit weekend neem ik ook een kijkje

[wizzopa]

Heren,
Ik heb als NOOB een simpele vraag, is het mogelijk met Espeasy 2x ESP8622 met elkaar te laten “praten” een doet de meting de andere de uitvoering van de meting.
Gebruikte firmware: ESP_Easy_mega_20220328_normal_ESP8266_4M1M

[RobertMe]

Raymond P schreef op vrijdag 6 mei 2022 @ 16:42:
@RobertMe Nee. Je verbind dus de ground van de 12V adapter aan de ground van je PC voeding, via de ESP, via USB.
Als je de ground van de adapter weg zou laten dan zou die 12V lijn dus helemaal niet 'lopen'.

Ik snapte nog steeds niet goed wat je bedoelde. Maar intussen ook een stukje gelezen van die thread op het Arduino forum die je eerder linkte. Daarin worden ook twee grounds gehanteerd met een extra lijntje tussen beiden. Dus in mijn situatie ga ik dan uit van:

• VCC van de L298N naar de + van de (AC) adapter
• Ground van L298N naar de - van de (AC) adapter
• ESP dan via USB aan PC
• GPIO outputs van ESP naar IN1 & IN2 van de L298N
• Additioneel een verbinding tussen de ground van de L298N naar de ground van de ESP

Dus zowel de - van de adapter, als (een van de) ground van de ESP aansluiten op de ground van de L298N. Correct? En dat een dan een 5V input heeft (en 3.3V output) en de ander 12V maakt niet uit? Waarschijnlijk dan dus ook doordat het gelijkstroom bevat die, i.t.t. wisselstroom, wel een richting bevat? (Als in: DC circuit werkt niet als je bv de batterij verkeerd om plaatst).

Vind ik het alleen een beetje een mysterie hoe dit dan werkt. Is het dan een geval van "de adapter 'verstuurt' X elektronen, de ESP 'verstuurt' via de GPIO Y elektronen. Doordat de adapter maar X elektronen 'verstuurt' accepteert deze ook maar X elektronen retour, waardoor de Y elektronen uit de ESP nergens heen kunnen"? En door dus de grounds met elkaar te verbinden kunnen de Y elektronen vanuit de ESP ook weer retour naar de ESP? En dat het dan om verschillende voltages gaat kan geen kwaad?

Van een ver verleden meen ik mij ook iets van een vergelijking met bv een treinspoor te herinneren. De elektronen zijn de wagons van bv een goederentrein, en dat amperage en voltage dan iets zeggen over hoe vol de wagons zijn (voltage?) en hoeveel wagons er zijn (amperage?). Is het in dit geval dan zo dat de ground de lege wagons zijn, en doordat ze leeg zijn het niet uit maakt dat er groter gevulde (12V) en kleiner gevulde wagons (3.3V) waren en waar deze terecht komen (AC adapter vs ESP).

[tsjoender]

wizzopa schreef op vrijdag 6 mei 2022 @ 16:52:
Heren,
Ik heb als NOOB een simpele vraag, is het mogelijk met Espeasy 2x ESP8622 met elkaar te laten “praten” een doet de meting de andere de uitvoering van de meting.
Gebruikte firmware: ESP_Easy_mega_20220328_normal_ESP8266_4M1M

Dat is zeker mogelijk met rules. Daar kun je prima condities definieren waar acties aan gekoppeld worden. Die acties kunnen op diezelfde ESP zijn, maar met een http api call ook op een ander device.

[wizzopa]

tsjoender schreef op vrijdag 6 mei 2022 @ 19:27:
[...]


Dat is zeker mogelijk met rules. Daar kun je prima condities definieren waar acties aan gekoppeld worden. Die acties kunnen op diezelfde ESP zijn, maar met een http api call ook op een ander device.

Dank voor je reactie, echter de rede dat ik met Espeasy werk is om geen rules te typen.

Ik had al een video gevonden over dit “ probleem “ maar daar kwam ook weer een een berg typewerk aan te pas.

Ja, als je de 70 nader vormt dat wel een probleem, mijn hoop was dus gevestigd op Espeasy.

Het gaat uiteindelijk maar om het aansturen van een relais module met 2 relais 1 voor een klep en de ander voor het op stand 3 zetten van ventilatie op basis van Co2.

[tsjoender]

wizzopa schreef op vrijdag 6 mei 2022 @ 19:38:
[...]

Dank voor je reactie, echter de rede dat ik met Espeasy werk is om geen rules te typen.

Ik had al een video gevonden over dit “ probleem “ maar daar kwam ook weer een een berg typewerk aan te pas.

Ja, als je de 70 nader vormt dat wel een probleem, mijn hoop was dus gevestigd op Espeasy.

Het gaat uiteindelijk maar om het aansturen van een relais module met 2 relais 1 voor een klep en de ander voor het op stand 3 zetten van ventilatie op basis van Co2.

Tsja als je zo weinig mogelijk wilt typen, dan is er misschien iets te doen met Domoticz ertussen en Blockly, of iets met node red. Maar wat je beschrijft is wellicht 15-20 regels aan rules en dan heb je geen extra device nodig voor Blockly of node red. Nooit mee gewerkt maar IFTTT is misschien ook wel iets wat weinig typewerk vergt.

[wizzopa]

tsjoender schreef op vrijdag 6 mei 2022 @ 19:44:
[...]


Tsja als je zo weinig mogelijk wilt typen, dan is er misschien iets te doen met Domoticz ertussen en Blockly, of iets met node red. Maar wat je beschrijft is wellicht 15-20 regels aan rules en dan heb je geen extra device nodig voor Blockly of node red. Nooit mee gewerkt maar IFTTT is misschien ook wel iets wat weinig typewerk vergt.

Ga dan toch maar “ even “ kijken of ik het met typen voor elkaar kan krijgen.

Je bent nooit te oud om te leren.

[Raymond P]

RobertMe schreef op vrijdag 6 mei 2022 @ 18:30:
[...]

Ik snapte nog steeds niet goed wat je bedoelde. Maar intussen ook een stukje gelezen van die thread op het Arduino forum die je eerder linkte. Daarin worden ook twee grounds gehanteerd met een extra lijntje tussen beiden. Dus in mijn situatie ga ik dan uit van:

• VCC van de L298N naar de + van de (AC) adapter
• Ground van L298N naar de - van de (AC) adapter
• ESP dan via USB aan PC
• GPIO outputs van ESP naar IN1 & IN2 van de L298N
• Additioneel een verbinding tussen de ground van de L298N naar de ground van de ESP

Dus zowel de - van de adapter, als (een van de) ground van de ESP aansluiten op de ground van de L298N. Correct? En dat een dan een 5V input heeft (en 3.3V output) en de ander 12V maakt niet uit? Waarschijnlijk dan dus ook doordat het gelijkstroom bevat die, i.t.t. wisselstroom, wel een richting bevat? (Als in: DC circuit werkt niet als je bv de batterij verkeerd om plaatst).

Correct.

Vind ik het alleen een beetje een mysterie hoe dit dan werkt. Is het dan een geval van "de adapter 'verstuurt' X elektronen, de ESP 'verstuurt' via de GPIO Y elektronen. Doordat de adapter maar X elektronen 'verstuurt' accepteert deze ook maar X elektronen retour, waardoor de Y elektronen uit de ESP nergens heen kunnen"? En door dus de grounds met elkaar te verbinden kunnen de Y elektronen vanuit de ESP ook weer retour naar de ESP? En dat het dan om verschillende voltages gaat kan geen kwaad?

Tjah, ik ga hier niet doen alsof ik het snap. Die elektronen blijken ook niet/nauwelijks te bewegen en de energie gaat niet door de kabels/traces maar door de magnetische velden eromheen.
Zo af en toe probeer ik daar wat dieper in te duiken en elke keer geloof ik een stukje meer in Jomanda's magische stenen.

[Raymond P]

@Atmoz Na het lezen van de api-ref is mijn eerste hit: https://github.com/SensorsIot/ESP32-ULP-Arduino-IDE

Het idee is dus dat je de coprocessor je ADC pin laat monitoren, bij het overschrijden van threshold de waarde wegschrijft naar geheugen waar je in je main toegang tot hebt en dus weer uit kunt lezen.

De code van de link op github heb ik niet getest maar ziet er naar mijn idee volledig logisch uit.
De bijgaande video van Andreas Spiess heb ik ook niet gekeken, dat trek ik niet. Wellicht ben jij dapperder.
Of had je deze al als niet-werkend bestempeld?

[Tanuki]

Raymond P schreef op zaterdag 7 mei 2022 @ 09:00:
@Atmoz Na het lezen van de api-ref is mijn eerste hit: https://github.com/SensorsIot/ESP32-ULP-Arduino-IDE

Het idee is dus dat je de coprocessor je ADC pin laat monitoren, bij het overschrijden van threshold de waarde wegschrijft naar geheugen waar je in je main toegang tot hebt en dus weer uit kunt lezen.

De code van de link op github heb ik niet getest maar ziet er naar mijn idee volledig logisch uit.
De bijgaande video van Andreas Spiess heb ik ook niet gekeken, dat trek ik niet. Wellicht ben jij dapperder.
Of had je deze al als niet-werkend bestempeld?

Wat is er mis met the guy with the Swiss accent?

[Raymond P]

@Tanuki Helemaal niets, het probleem ligt bij mij. De beste man is uiterst succesvol om mij in deep sleep te krijgen.

[Tanuki]

Raymond P schreef op zaterdag 7 mei 2022 @ 09:10:
@Tanuki Helemaal niets, het probleem ligt bij mij. De beste man is uiterst succesvol om mij in deep sleep te krijgen.

Ik wil het best met je eens zijn dat zijn video's wat eentonig klinken. Het is maar soms dat er een stukje enthousiasme doorsijpelt. Eigenlijk wel jammer.

Want de man heeft heel veel kennis en zeer informatieve video's en is misschien wel een van de meest waardevolle bronnen in de esp community. Al heel veel van hem geleerd.

[ Voor 3% gewijzigd door Tanuki op 07-05-2022 09:19 ]

[Raymond P]

Yep. Helemaal eens.

[Atmoz]

Raymond P schreef op zaterdag 7 mei 2022 @ 09:00:
@Atmoz Na het lezen van de api-ref is mijn eerste hit: https://github.com/SensorsIot/ESP32-ULP-Arduino-IDE

Jep, die bij ik ook al meerdere keren tegen gekomen in mijn langdurige zoektocht naar iets werkends.
Het probleem is alleen: hoe lang ik er ook naar kijk, ik kom niet zover dat ik alles snap.

Wat ik wel snap (denk ik), is dat dit voor mij niet gaat werken.
Want ergens heeft hij dit staan:

code:

/* Set ULP wake up period to 100ms */
  ulp_set_wakeup_period(0, 100 * 1000);

En dat strookt ook een beetje met wat jij schrijft:

Het idee is dus dat je de coprocessor je ADC pin laat monitoren, bij het overschrijden van threshold de waarde wegschrijft naar geheugen waar je in je main toegang tot hebt en dus weer uit kunt lezen.

En dat is dus niet wat ik zoek.

Het liefst zou ik willen dat de main-processor constant slaapt, en DIRECT (dus niet na 100ms ofzo) wakker wordt zodra die ingestelde waarde ook maar 1x overschreden wordt.

Oh wacht eens even... misschien is dit wél wat ik zoek!

Tenminste, klopt het dat het zo werkt:

De main processor is constant aan het slapen, en in ULP wordt door de coprocessor CONSTANT (dus vaker dan 1x per 100ms*) de ADC uitgelezen. Vervolgens wordt deze waarde opgeslagen (in een bepaald geheugen waar ook de main-processor bij kan). En vervolgens wordt iedere 100ms de main-processor wakker gemaakt om te checken of de waarde overschreden is?

Dit is iets anders dan mijn wens: ik wilde eigenlijk nooit de main-processor wakker maken TOTDAT de ADC waarde overschreden werd. Maar als dat niet kan (of te moeilijk is) dan is dit inderdaad een goed alternatief. Straks als ik weer thuis ben direct testen

Of had je deze al als niet-werkend bestempeld?

Ja, dat had ik eigenlijk wel al. Zelfs zonder te testen, want ik ging er dus vanuit dat dit niet is wat ik zocht...


*als er echt maar 1x per 100ms naar de ADC gekeken wordt heeft het voor mij geen zin

[Raymond P]

@Atmoz De docs leggen dat uit: https://docs.espressif.co...up_period6size_t8uint32_t

edit: en in de git repo staat het ook netjes: https://github.com/Sensor...15c/ulp_adc/adc.s#L11-L17

De main processor wordt niet wakker gemaakt tenzij er aan de condities voldaan wordt (threshold).
De ULP coprocessor wordt wakker gemaakt om een run (of meerdere) te doen, indien wenselijk kan je er ook voor kiezen 'm dus continue te laten draaien.

Een factor 500 vaker dan die 1x per 100ms lijkt mij geheel haalbaar. Volgens de docs:

For a default configuration of the ULP running at 150kHz it makes about 133us.

Net geen 8 volledige cycles in één ms dus.

Elke cycle die je doet kost natuurlijk energie, waar jij het balans vind tussen verbruik en performance heb ik geen zicht op.
En daar ligt ook de crux, als 100ms te lang is dan duurt het wekken van de ESP mogelijk ook te lang. Vrijwel zeker als je ook daadwerkelijk gebruik maakt van wifi en/of bluetooth.

edit2:
In jouw specifieke geval kom je waarschijnlijk wel weg met wake stub: https://docs.espressif.co...ides/deep-sleep-stub.html
Daarmee kan je een stukje code runnen voordat de rest geïnitialiseerd wordt na deep sleep (wat makkelijk een paar honderd ms kan duren).

[ Voor 23% gewijzigd door Raymond P op 07-05-2022 10:43 ]

[tsjoender]

wizzopa schreef op vrijdag 6 mei 2022 @ 19:55:
[...]

Ga dan toch maar “ even “ kijken of ik het met typen voor elkaar kan krijgen.

Je bent nooit te oud om te leren.

Hier een voorbeeldje om je op gang te helpen met rules:

code:

on CO2#PPM do
  if [CO2#PPM]>1000
     SendToHTTP 192.168.1.2,80,/control?cmd=GPIO,15,1
  else
     SendToHTTP 192.168.1.2,80,/control?cmd=GPIO,15,0
  endif
endon

In dit voorbeeld is er een device met de naam CO2. En die heeft een value met de naam PPM. Als er een event is waarbj de value van PPM bijgewerkt wordt, dan wordt er gekeken of de waarde groter is dan 1000. In dat geval wordt GPIO 15 op een ESPEasy device met IP adres 192.168.1.2 hoog (bijvoorbeeld inschakelen relais (al zul je bij sommigen dan juist laag moeten zetten)) en anders stuurt die het commando waarbij die GPIO laag wordt.

[wizzopa]

tsjoender schreef op zaterdag 7 mei 2022 @ 12:47:
[...]


Hier een voorbeeldje om je op gang te helpen met rules:

code:

on CO2#PPM do
  if [CO2#PPM]>1000
     SendToHTTP 192.168.1.2,80,/control?cmd=GPIO,15,1
  else
     SendToHTTP 192.168.1.2,80,/control?cmd=GPIO,15,0
  endif
endon

In dit voorbeeld is er een device met de naam CO2. En die heeft een value met de naam PPM. Als er een event is waarbj de value van PPM bijgewerkt wordt, dan wordt er gekeken of de waarde groter is dan 1000. In dat geval wordt GPIO 15 op een ESPEasy device met IP adres 192.168.1.2 hoog (bijvoorbeeld inschakelen relais (al zul je bij sommigen dan juist laag moeten zetten)) en anders stuurt die het commando waarbij die GPIO laag wordt.

Dank je wel.👍

[Atmoz]

@Raymond P thanks!

Dat ziet er in principe allemaal érg goed uit

Alleen heb ik nu ineens een ander probleem... Het lijkt wel alsof ik weer in m'n studententijd* zit. Waar er uren en uren voorbij gingen aan het proberen te fixen dat de IDE überhaupt iets compileert

Want het is weer zover; ik krijg dat voorbeeld echt op geen enkele manier gecompileerd. Ik heb (op 2 PC's inmiddels) verschillende versies van de Arduino IDE en verschillende ESP32 cores geprobeerd, en misschien wel 10x deze stappen gedaan. Ook heb ik met Pyhton versies zitten stoeien (nu heb ik er 2.7.18 op staan). Niets helpt en ik krijg (in verschillende situaties) steeds meer/andere foutmeldingen van de Arduino IDE.

In de huidige "stand" zijn dit de foutmeldingen:

sketch\ulp_adc.ino.cpp.o:(.literal._Z5setupv+0x28): undefined reference to `ulp_low_threshold'
sketch\ulp_adc.ino.cpp.o:(.literal._Z5setupv+0x2c): undefined reference to `ulp_high_threshold'
sketch\ulp_adc.ino.cpp.o:(.literal._Z5setupv+0x3c): undefined reference to `ulp_sample_counter'
sketch\ulp_adc.ino.cpp.o:(.literal._Z5setupv+0x48): undefined reference to `ulp_ADC_reading'
sketch\ulp_adc.ino.cpp.o:(.literal._Z5setupv+0x50): undefined reference to `ulp_entry'
collect2.exe: error: ld returned 1 exit status
exit status 1
Fout bij het compileren voor board ESP32 Wrover Module

Dit heeft niets meer met programmeren te maken, maar gewoon met je kapot ergeren. Achja, dat hoort er ook weer eens bij zullen we maar zeggen he...

*een geluk bij een ongeluk; bij de studententijd hoort bier, dus dan zal ik me zometeen maar alvast eentje pakken

[Atmoz]

Yes! Het werkt

Ik had 2 mensen op Upwork betaald die beide zeiden dat ze het binnen 3 dagen konden maken.
Uiteindelijk heb ik van beide na 10 dagen helemaal niets gekregen. Echt verschrikkelijk hoe slecht dat daar werkt Maar eens kijken of/hoe ik daar m'n geld kan terughalen...

Maargoed, het werkt dus nu Wederom mede dankzei de goede hulp hier op GoT

Het voorbeeld van de man met het Swiss accent was helaas niet compleet:

code:

init_ulp_program();

moest ook nog in het stukje waar "// ***** HERE YOUR SKETCH *****" staat.

Maar met behulp van zijn code + de hulp hier op GoT ben ik er dus wel uitgekomen.

Weer een mooie uitdaging (voor mij dan) kunnen afvinken!

[Waah]

nvm, zoek eerst even zelf

[ Voor 100% gewijzigd door Waah op 09-05-2022 11:38 ]

[Gizz]

@Waah op de ESP8266 draait firmware. Die firmware is met behulp van ESPHome gemaakt.

De ESPHome folder waarnaar verwezen wordt betreft ESPHome die je bijvoorbeeld in Home Assistant hebt draaien (waar je de nieuwe firmwares kunt 'bakken' en uploaden naar de ESP8266). Het gaat hier dus niet om een map die op de ESP8266 zelf staat.

Heb je al ESPHome draaien in Home Assistant? Of standalone, bijvoorbeeld in Docker? Dat is de plek waar je moet zijn. Je moet daar deze bestanden neerzetten zodat ESPHome die informatie kan gebruiken op het moment dat hij de firmware opnieuw gaat maken (compilen) die je op de ESP8266 zet

[CurlyMo]

@Atmoz deel je zelf de boel ook op github?

[ Voor 4% gewijzigd door CurlyMo op 09-05-2022 11:57 ]

[Waah]

Gizz schreef op maandag 9 mei 2022 @ 11:48:
@Waah op de ESP8266 draait firmware. Die firmware is met behulp van ESPHome gemaakt.

De ESPHome folder waarnaar verwezen wordt betreft ESPHome die je bijvoorbeeld in Home Assistant hebt draaien (waar je de nieuwe firmwares kunt 'bakken' en uploaden naar de ESP8266). Het gaat hier dus niet om een map die op de ESP8266 zelf staat.

Heb je al ESPHome draaien in Home Assistant? Of standalone, bijvoorbeeld in Docker? Dat is de plek waar je moet zijn. Je moet daar deze bestanden neerzetten zodat ESPHome die informatie kan gebruiken op het moment dat hij de firmware opnieuw gaat maken (compilen) die je op de ESP8266 zet

Ah oke, duidelijk.

Ik heb de ESPHome niet zelf geinstalleerd, dus deze staat ook niet in de ESPHome dashboard in Home Assistant. En ik begrijp dat je die niet kan toevoegen. Dus ik zal hem voor nu via USB moeten updaten voor de eerste keer.

Ga ik mee aan de slag. Bedankt voor de duw in de goede richting!

[Atmoz]

CurlyMo schreef op maandag 9 mei 2022 @ 11:57:
@Atmoz deel je zelf de boel ook op github?

Oh, daar heb ik eerlijk gezegd 0,0 ervaring mee... Ik wist ook niet dat ik daar zélf ook dingen kan posten.
Ik dacht dat dat alleen voor mensen was die complete code/projecten wilden delen enzo

Maar als dat handig is dan wil ik dat best doen natuurlijk

Heb even gekeken waar je allemaal iets kunt posten, maar een forum is er volgens mij niet..
Je bedoeld dan een issue melden, ofzo?

[edit]

Oh, een forum blijken ze wel te hebben, maar het feit dat ik dat nog nooit ergens ben tegen gekomen zal wel betekenen dat het niet zoveel voor stelt

[ Voor 11% gewijzigd door Atmoz op 09-05-2022 12:20 ]

[CurlyMo]

Atmoz schreef op maandag 9 mei 2022 @ 12:18:
[...]


Oh, daar heb ik eerlijk gezegd 0,0 ervaring mee... Ik wist ook niet dat ik daar zélf ook dingen kan posten.
Ik dacht dat dat alleen voor mensen was die complete code/projecten wilden delen enzo

Check sowieso even of de code die je hebt gebruikt en/of de snippets die je hebt gekopieerd wel onder een open source licentie zijn gedeeld, en welke licentie dat dan is. Want het kan zijn dat je dan verplicht bent zelf ook je code (open source) te delen. In geval van afwezigheid van een licentie dan is de kans dat je het sowieso alleen maar voor privé doeleinden mag gebruiken.

[Atmoz]

CurlyMo schreef op maandag 9 mei 2022 @ 13:03:
[...]

Check sowieso even of de code die je hebt gebruikt en/of de snippets die je hebt gekopieerd wel onder een open source licentie zijn gedeeld, en welke licentie dat dan is. Want het kan zijn dat je dan verplicht bent zelf ook je code (open source) te delen. In geval van afwezigheid van een licentie dan is de kans dat je het sowieso alleen maar voor privé doeleinden mag gebruiken.

Ahzo, op die manier bedoel je dat!
Ja, dat is een goede

Gelukkig heeft Google het verlossende antwoord:

can I use CC0 licensed code in my product?

Yes. CC0 doesn't restrict who can use a CC0'd work. Once applied, anyone can use the work in any way and for any purpose, including commercial purposes, subject to rights others may have in the work or how it's used, as well as subject to any other laws or restrictions that may apply.

Maar dat is dus ook weer iets wat ik in de gaten moet houden. Thanks!

[Raymond P]

@Atmoz Gezien je gehobby daadwerkelijk een product produceert heeft @CurlyMo inderdaad een punt.

Nu kan het zijn dat ik eroverheen lees maar ik zie geen Creative Commons badge of vermelding.
De auteur van dat stukje code heeft geen licentie opgegeven dus standaard auteursrecht van toepassing.

[ThinkPad]

Ik heb een ESP8266 met een 6-tal DS18B20 sensoren er aan. Eerst stond hier ESPEasy op, maar ik heb een voorkeur voor Tasmota.

Heb een screenshot gemaakt van welke sensor welk doel had, met de ID's erbij. Dit met de gedachte dat als ik Tasmota erop had geflashed ik zo weer up and running was.

Maar de ID's in Tasmota zijn anders dan die in ESPEasy whut!?

Iemand een idee hoe dit zit? Ik haal het liefste niet de sensoren los, is gesoldeerd en kan er sowieso niet heel goed bij.

ESPEasy:


Tasmota:

JSON:

{"StatusSNS":
{"Time":"2022-05-09T19:23:44",
"DS18B20-1":{"Id":"020191770722","Temperature":15.1},
"DS18B20-2":{"Id":"020A92466AC9","Temperature":15.7},
"DS18B20-3":{"Id":"020A92466C4A","Temperature":14.6},
"DS18B20-4":{"Id":"02119246ECAE","Temperature":15.3},
"DS18B20-5":{"Id":"021491777231","Temperature":15.4},
"DS18B20-6":{"Id":"021891774F1C","Temperature":15.1},
"TempUnit":"C"}}

Edit: nu ik er nog eens goed naar kijk zo naast elkaar zie ik wel e.e.a. aan gelijkenis. Maar de ID's staan in een andere soort notatie lijkt het. Maar een stuk of 5-6 karakters zie ik wel terugkomen.

[ Voor 8% gewijzigd door ThinkPad op 09-05-2022 19:37 ]

[Raymond P]

@ThinkPad https://github.com/arends..._05_ds18x20.ino#L491-L495

Die 6 kan wel kloppen ja.

maw:

020191770722 > omdraaien >
22-07-77-91-01-02 == 28-22-7-77-91-1-2-42

[ Voor 22% gewijzigd door Raymond P op 09-05-2022 20:12 ]

[ThinkPad]

Ja heb het inmiddels helder En met die link naar code bedoel je dat ESPEasy Tasmota maximaal 6 sensoren ondersteunt? Wist ik niet, toevallig heb ik er daadwerkelijk zoveel in gebruik

[ Voor 4% gewijzigd door ThinkPad op 09-05-2022 20:17 ]

[Raymond P]

Tasmota ondersteunt er standaard 8, dat kan je wel overwriten.

De link laat de loop van 6 zien en het 'foutje' van achterstevoren wegschrijven. Vanaf line 491 als de # niet werkt.

[Atmoz]

Raymond P schreef op maandag 9 mei 2022 @ 17:24:
@Atmoz Gezien je gehobby daadwerkelijk een product produceert heeft @CurlyMo inderdaad een punt.

Nu kan het zijn dat ik eroverheen lees maar ik zie geen Creative Commons badge of vermelding.
De auteur van dat stukje code heeft geen licentie opgegeven dus standaard auteursrecht van toepassing.

Dit staat er bij die code op GitHub:

This example code is in the Public Domain (or CC0 licensed, at your option.)

Er is trouwens weer een nieuw probleem ontstaan

Ik wil de processor namelijk op 3 verschillende manier uit deep-sleep halen:

1. met een IO pin (druktoets)
2. met een analoge (ADC) pin (waar het hier de hele tijd over ging)
3. met een timer

Alle 3 werken (apart van elkaar) heel goed, dus dat is alvast een goed begin

Maar nu heb ik het volgende aan de hand:
Als ik de ESP met de druktoets uit deep-sleep haal, dan werkt de volgende "deep-sleep-ronde" het ontwaken m.b.v. de ADC niet meer.
Dus het ADC gebeuren werkt eigenlijk alleen maar zolang ik niet die druktoets gebruik.

Komt dat misschien iemand bekend voor?

[CurlyMo]

@Atmoz zolang je de code niet deelt (op GitHub) is het lastig meekijken.

[Raymond P]

@Atmoz Dat staat inderdaad in de assembly file, niet in de c++ file.

Wat betreft je issue, ik gok dat je niet expliciet esp_sleep_enable_ulp_wakeup() called voordat je weer deep sleep in gaat. Je ULP coprocessor is dus 'klaar'.

[ Voor 8% gewijzigd door Raymond P op 09-05-2022 20:32 ]

[Atmoz]

CurlyMo schreef op maandag 9 mei 2022 @ 20:29:
@Atmoz zolang je de code niet deelt (op GitHub) is het lastig meekijken.

Raymond P schreef op maandag 9 mei 2022 @ 20:32:
Wat betreft je issue, ik gok dat je niet expliciet esp_sleep_enable_ulp_wakeup() called voordat je weer deep sleep in gaat. Je ULP coprocessor is dus 'klaar'.

Nee, dat is het helaas niet.


Hierbij de code waar het ergens mis gaat:

Bovenaan bij de declaraties heb ik:

code:

extern const uint8_t ulp_main_bin_start[] asm("_binary_ulp_main_bin_start");
extern const uint8_t ulp_main_bin_end[]   asm("_binary_ulp_main_bin_end");

#define BUTTON_PIN_BITMASK 0x4000  //bitmask voor drukschakelaar op IO14

In setup() doe ik:

code:

esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ALL_LOW); //druktoets om ESP uit slaap te halen

En even later -ook in setup()- doe ik:

code:

if (EnableSleep){
  esp_sleep_wakeup_cause_t WakkerMaakReden = esp_sleep_get_wakeup_cause();
  if (WakkerMaakReden != ESP_SLEEP_WAKEUP_ULP){
    SendUDP("Reden van wakker maken was niet ULP"); 
    delay(1000);  
    init_ulp_program();
  } else {
    ulp_ADC_reading &= UINT16_MAX;
    SendUDP("ESP_SLEEP_WAKEUP_ULP");
    SendUDP("ulp_ADC_reading: " + String(ulp_ADC_reading));  
    delay(1000);

    init_ulp_program(); //Dit moet hier staan anders werkt het niet

  }
  
  SendUDP("Slaapstand starten"); 
  delay(1000);
  start_ulp_program();
  ESP_ERROR_CHECK(esp_sleep_enable_ulp_wakeup());

  esp_sleep_enable_timer_wakeup(rtc_timer_in_seconds * convert_to_microseconds);  //Iedere 20 sec. even wakker maken (werkt i.c.m. ADC uitlezen)
  esp_deep_sleep_start();

}

En dan nog de 2 bijbehorende routines:

code:

static void init_ulp_program()
{
  esp_err_t err = ulp_load_binary(0, ulp_main_bin_start,
                                  (ulp_main_bin_end - ulp_main_bin_start) / sizeof(uint32_t));
  ESP_ERROR_CHECK(err);

  digitalWrite(POWER, HIGH); //pcb power
  digitalWrite(26, HIGH);    //tcrt led power

  gpio_hold_en(GPIO_NUM_13); //pcb power
  gpio_hold_en(GPIO_NUM_26); //tcrt power
  gpio_deep_sleep_hold_en(); 

  adc1_config_channel_atten(ADC1_CHANNEL_4, ADC_ATTEN_DB_11);
  adc1_config_width(ADC_WIDTH_BIT_12);
  adc1_ulp_enable();
  ulp_low_threshold = 4090; 
  ulp_high_threshold = 4096;   
  ulp_set_wakeup_period(0, 40 * 1000);

}

code:

static void start_ulp_program()
{
  esp_err_t err = ulp_run((&ulp_entry - RTC_SLOW_MEM) / sizeof(uint32_t));
  ESP_ERROR_CHECK(err);
}

Alles werkt, en zodra ik (in sleep) op de druktoets druk, dan wordt de processor ook netjes wakker, maar als die vervolgens weer gaat slapen dan kan ik hem niet meer wakker maken met de sensor/ADC. Het wakker maken middels timer en druktoets blijft echter wél werken....

[Seafarer]

Raymond P schreef op maandag 9 mei 2022 @ 20:17:
Tasmota ondersteunt er standaard 8, dat kan je wel overwriten.

De link laat de loop van 6 zien en het 'foutje' van achterstevoren wegschrijven. Vanaf line 491 als de # niet werkt.

Klopt. Meer had ik nog niet geprobeerd.

[RobertMe]

@Raymond P Net eindelijk even de tijd genomen om te testen met een extra lijntje tussen de ground van de ESP en de L298N, en inderdaad, nu werkt de schakeling en kan ik met een multimeter netjes 12V meten (of in mijn test, -12V ). Oftewel: de grounds met elkaar verbinden was de oplossing. Nogmaals dank dus

[Atmoz]

Atmoz schreef op dinsdag 10 mei 2022 @ 08:27:

....

Alles werkt, en zodra ik (in sleep) op de druktoets druk, dan wordt de processor ook netjes wakker, maar als die vervolgens weer gaat slapen dan kan ik hem niet meer wakker maken met de sensor/ADC. Het wakker maken middels timer en druktoets blijft echter wél werken....

Is er nog iemand hier die nog een idee heeft zodat ik dit probleem hopelijk opgelost krijg?

Ik kom er maar niet achter wat voor deze gekke situatie zorgt... Dus alle hulp hierbij is uiteraard welkom

[CurlyMo]

Atmoz schreef op vrijdag 13 mei 2022 @ 09:32:
[...]


Is er nog iemand hier die nog een idee heeft zodat ik dit probleem hopelijk opgelost krijg?

Ik kom er maar niet achter wat voor deze gekke situatie zorgt... Dus alle hulp hierbij is uiteraard welkom

Staat de code al ergens?

[Atmoz]

@CurlyMo hierbij de ontbrekende code die er nog bij hoort:


ulp_main.h

code:

#include "Arduino.h"

extern uint32_t ulp_entry;
extern uint32_t ulp_sample_counter;
extern uint32_t ulp_low_threshold;
extern uint32_t ulp_high_threshold;
extern uint32_t ulp_ADC_reading;

adc.s

code:

#include "soc/rtc_cntl_reg.h"
#include "soc/rtc_io_reg.h"
#include "soc/soc_ulp.h"

.set adc_channel, 4

.set adc_oversampling_factor_log, 1
.set adc_oversampling_factor, (1 << adc_oversampling_factor_log)

/* Define variables, which go into .bss section (zero-initialized data) */
.bss

/* Low threshold of ADC reading.
   Set by the main program. */
.global low_threshold
low_threshold: .long 0

/* High threshold of ADC reading.
   Set by the main program. */
.global high_threshold
high_threshold: .long 0

/* Counter of measurements done */
.global sample_counter
sample_counter:
.long 0

.global ADC_reading
ADC_reading:
.long 0

/* Code goes into .text section */
.text
.global entry
entry:
/* Disable hold of GPIO13 output */
//WRITE_RTC_REG(RTC_IO_TOUCH_PAD4_REG, RTC_IO_TOUCH_PAD4_HOLD_S, 1, 0)
/* Set the GPIO13 output HIGH */
//WRITE_RTC_REG(RTC_GPIO_OUT_W1TS_REG, RTC_GPIO_OUT_DATA_W1TS_S + 14, 1, 1)

/* increment sample counter */
move r3, sample_counter
ld R2, r3, 0
add R2, R2, 1
st R2, r3, 0

/* do measurements using ADC */
/* r0 will be used as accumulator */
move r0, 0
/* initialize the loop counter */
stage_rst

measure:
/* measure and add value to accumulator */
adc r1, 0, adc_channel + 1
add r0, r0, r1
/* increment loop counter and check exit condition */
stage_inc 1
jumps measure, adc_oversampling_factor, lt

/* divide accumulator by adc_oversampling_factor.
   Since it is chosen as a power of two, use right shift */
rsh r0, r0, adc_oversampling_factor_log
/* averaged value is now in r0; store it into ADC_reading */
move r3, ADC_reading
st r0, r3, 0


/* compare with low_threshold; wake up if value < low_threshold */
move r3, low_threshold
ld r3, r3, 0
sub r3, r0, r3
jump wake_up, ov


/* value within range, end the program */
.global exit
exit:
/* Set the GPIO13 output LOW (clear output) to signal that ULP is now going down */
//WRITE_RTC_REG(RTC_GPIO_OUT_W1TC_REG, RTC_GPIO_OUT_DATA_W1TC_S + 14, 1, 1)
/* Enable hold on GPIO13 output */
//WRITE_RTC_REG(RTC_IO_TOUCH_PAD4_REG, RTC_IO_TOUCH_PAD4_HOLD_S, 1, 1)
halt

.global wake_up
wake_up:
/* Check if the system can be woken up */
READ_RTC_FIELD(RTC_CNTL_LOW_POWER_ST_REG, RTC_CNTL_RDY_FOR_WAKEUP)
and r0, r0, 1
jump exit, eq

/* Wake up the SoC, end program */
wake
WRITE_RTC_FIELD(RTC_CNTL_STATE0_REG, RTC_CNTL_ULP_CP_SLP_TIMER_EN, 0)
jump exit

De rest van de code staat in deze post.


M'n vader dacht dat het misschien een hardware-probleem zou zijn, maar als ik de code voor het ontwaken met button uit vink, en ik druk dan op de toets (de ESP ontwaakt dan uiteraard niet), dan werkt de ADC wel nog gewoon. Dus met de hardware is (gelukkig) niets mis

[CurlyMo]

@Atmoz Ik noemde github al als plek om je hele project te delen. Zolang ik er niet in zijn geheel naar kan kijken wordt het moeilijk om te helpen. Het forum hier is niet de plek om dat te doen.

[Waah]

Ik heb weer ff een hardware-aansluitvraagje...

Nog bezig met de kast, en heb nu gaten geboord zodat de kabels onzichtbaar weggewerkt kunnen worden. So far so good.

Echter heb ik straks 3 aparte ledstrips, die ik moet verbinden met 5v én het ESP32 board.. Mijn idee was om de 5v aan te sluiten op een lasklem, en van daaruit te verbinden met de ledstrips en de ESP32. Idem voor ground. De Data-lines krijgen een directe verbinding met het ESP32 board.

Maar: Hoe verbind je losse draden het beste met de pins op een ESP-boardje? Een losse draad solderen op een pin voelt.... verkeerd. En de meeste tutorials die ik zie werken met die dupont draadjes wat top is voor te testen. Maar hoe je van een testproject naar een net afgewerkt project gaat, die stap slaat iedereen op Youtube over ;-)

En een lasklem is best wel groot en ook rommelig voor splitsen van de draden. Dus als dat ook anders kan graag.

Misschien mis ik gewoon de basiscursus werken met kleine electronica dus als iemand daar een tutorial/videoserie/training voor weet houd ik me aanbevolen

[ Voor 16% gewijzigd door Waah op 16-05-2022 15:52 ]