Viszonylag elterjedt, máshol is ezt használom ha csak úgy be akarok égetni egy-egy képet, ikont, de ez ESP-n katasztrófa.

Cél /lett volna/ az assembly korszakot idéző byte-ok vesszővel elválasztva ábrázolás elkerülése is:

Ilyet nem láttam eddig sehol máshol, ez a kőkorszak csúcsa.

[ Szerkesztve ]

Nem tudom, mitől lenne kőkorszak egy bájttömb bájtokkal való inicializálása, de OK.

I did nothing, the pavement was his enemy!

10 kb byte lista vesszővel elválasztva a forráskódban tényleg nem gáz?

De, eléggé. Mi vagy te, ősember? 🤔
Tessék szépen átírni oktálisra. 🧐

Az a gáz, hogy Te a forráskódba akarod rakni!
Html, képek, adatbázis, stb. a fájlrendszerben a helye.

Nem kötelező jelleggel. Ha csak 1-2 ilyen van, és elfér, miért ne lehetne egy header file-ban? Gyorsabb az elérése, nem kell szöszmötölni a feltöltéssel sem.

I did nothing, the pavement was his enemy!

Így van, már csak az ESP-t kell kivenni a képletből..

Komolyra fordítva a szót, akit tud egy base64 dekódolót ESP alatt:

byte[] rawimg = base64::decode(base64png);

ne kíméljen.

Pl. 8-as esp hosszabbító, html,css,js,favicon( ) littlefs-ben.
Ha a program magja OK, ezeket a stiláris elemeket könnyebb szerkeszteni,
nem kell állandóan fordítgatni.

[link]

I did nothing, the pavement was his enemy!

#include <iostream??>
auto?? s = from_base64("SGVsbG8sIFdvcmxkIQ==");

???

I did nothing, the pavement was his enemy!

Ez nem valamilyen C++ v11 vagy magasabb verziójú kód? Ard IDE-ben lefordul?

Hát, ha nem próbálod ki, sosem tudjuk meg. Amúgy le kellene neki. Ha nem, átírod valami régebbire.

I did nothing, the pavement was his enemy!

Ard IDE millió hibát dob a base64.hpp-ban.
"only available from C++17 onwards"

chatgpt mire van? Mondjuk nem teszteltem.

#ifndef BASE_64_HPP
#define BASE_64_HPP

#include <algorithm>
#include <cstdint>
#include <stdexcept>
#include <string>

namespace base64 {

const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

template <class OutputBuffer, class InputIterator>
inline OutputBuffer encode_into(InputIterator begin, InputIterator end) {
static_assert(std::is_same<typename std::decay<decltype(*begin)>::type, char>::value
|| std::is_same<typename std::decay<decltype(*begin)>::type, unsigned char>::value
|| std::is_same<typename std::decay<decltype(*begin)>::type, uint8_t>::value);

size_t counter = 0;
uint32_t bit_stream = 0;
size_t offset = 0;
OutputBuffer encoded;
encoded.reserve(static_cast<size_t>(1.5 * static_cast<double>(std::distance(begin, end))));
while (begin != end) {
auto const num_val = static_cast<uint8_t>(*begin);
offset = 16 - counter % 3 * 8;
bit_stream += num_val << offset;
if (offset == 16) {
encoded.push_back(base64_chars[bit_stream >> 18 & 0x3f]);
}
if (offset == 8) {
encoded.push_back(base64_chars[bit_stream >> 12 & 0x3f]);
}
if (offset == 0 && counter != 3) {
encoded.push_back(base64_chars[bit_stream >> 6 & 0x3f]);
encoded.push_back(base64_chars[bit_stream & 0x3f]);
bit_stream = 0;
}
++counter;
++begin;
}
if (offset == 16) {
encoded.push_back(base64_chars[bit_stream >> 12 & 0x3f]);
encoded.push_back('=');
encoded.push_back('=');
}
if (offset == 8) {
encoded.push_back(base64_chars[bit_stream >> 6 & 0x3f]);
encoded.push_back('=');
}
return encoded;
}

inline std::string to_base64(const std::string& data) {
return encode_into<std::string>(data.begin(), data.end());
}

template <class OutputBuffer>
inline OutputBuffer decode_into(const std::string& data) {
using value_type = typename OutputBuffer::value_type;
static_assert(std::is_same<value_type, char>::value
|| std::is_same<value_type, unsigned char>::value
|| std::is_same<value_type, uint8_t>::value);

size_t counter = 0;
uint32_t bit_stream = 0;
OutputBuffer decoded;
decoded.reserve(data.size());
for (unsigned char c : data) {
auto const num_val = base64_chars.find(c);
if (num_val != std::string::npos) {
auto const offset = 18 - counter % 4 * 6;
bit_stream += static_cast<uint32_t>(num_val) << offset;
if (offset == 12) {
decoded.push_back(static_cast<value_type>(bit_stream >> 16 & 0xff));
}
if (offset == 6) {
decoded.push_back(static_cast<value_type>(bit_stream >> 8 & 0xff));
}
if (offset == 0 && counter != 4) {
decoded.push_back(static_cast<value_type>(bit_stream & 0xff));
bit_stream = 0;
}
} else if (c != '=') {
throw std::runtime_error("Invalid base64 encoded data");
}
counter++;
}
return decoded;
}

inline std::string from_base64(const std::string& data) {
return decode_into<std::string>(data);
}

} // namespace base64



#endif // BASE_64_HPP

[ Szerkesztve ]

I did nothing, the pavement was his enemy!

Lapra nem próbáltam feltenni, de ennek a példakódja simán fordul nálam...

Alex

Amikor installálok egy lib-et Ard IDE-ben, aminek a neve ugyanaz mint ami az ESP core-ban is van (base64.h), akkor hogyan tudok hivatkozni az installált lib-re?

#include "Base64.h"
#include <Base64.h>
Mindkettő az esp32 core-ra mutat. (\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.6\cores\esp32)

Az installált lib meg itt van: \Documents\Arduino\libraries\Base64\src\base64.h

Nézd mit találtam neked byte code-ingra:
Ez kell [NEKED]

Van még ott egy csomó jópofa dolog.

PROGMEM:
[Pedig itt]

[ Szerkesztve ]

Nekem ez kínai (pedig japán).

Google Translate. Az a durva hogy nekem a chrome automatikusan felkínálja hogy angolra fordítsa le az oldalt. DE ha nem így működne, akkor
[IDE] kattintva bemásolod az URL-t és a kiválasztott fordítandó nyelv alatt megnyitod az URL-t és lőn a teljes oldal szépen ugyanúgy formázva megjelenik olyan nyelven amit szeretnél.

Mást is érdekelhet, ezért leírom:
A legbiztosabb, ha beteszed a kívánatosat az .ino mellé, akkor biztosan azt használja.
Ha ott nem találja, akkor (nálam, mert én portable-t használok) a sketchbook\libraries mappában keres, majd így tovább. Ha végképp keveredik, akkor be kell írni az include-ba a teljes elérési úttal. Ez biztos módszer.
Sajnos hiába írják ezer helyen, hogy, ha valaki ír egy könyvtári programot, ne adjon neki általános nevet, hanem egyedit. Én pl. a saját könyvtáraim nevébe a dátumot is beírom, vagy valami más egyedit.

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

>> A legbiztosabb, ha beteszed a kívánatosat az .ino mellé, akkor biztosan azt használja.
Sajna nem [link] , csak akkor ha " " jelek között van a forráskódban.
Gondot okozhat még az include fájlban lévő #ifndef feltétel.
A példát tekintve az #ifndef Base64 és az #ifndef base64 nem ugyan az, ellenőrizned kell van-e ilyen a tervezett include fájlban.

Aki jót akar magának az kezdjen el VSC-zni, Arduino helyett.

VSC miben előrelépés, mindkettő egy Electron szövegszerkesztőben szerencsétlenkedik. Nem értem miért nincs egy rendes VS támogatás?

A .pio\libdeps alatt az environments.ini-ben lévő boardnak megfelelő könyvtárakban kedvednek megfelelően szerkesztheted a forrásokat. Ezt Arduino IDE-vel szerintem nem tudod megtenni.

Ad abszurdum, én sem tudom mikor mit kell
Leírod?

[ Szerkesztve ]

Jól hitted: https://github.com/Microsoft/vscode/
Akkor most karddal vagy pisztollyal fogsz pontot tenni a vita végére?

Nincs sok tapasztalatom az Arduino-val kapcsolatban, ezért kérnék némi iránymutatást. Ezt a "kamera piros lámpa kapcsoló" projektet szeretném megépíteni, kis módosítással. Mégpedig úgy, hogy egyetlen Arduino eszköz csatlakozna a helyi hálózatra, és az i/o portjain keresztül vezérelne a lámpákat kapcsoló relémodult.

- A fenti "kész" projektből induljak ki, vagy az általa is használt eredeti Library-ból "nulláról" kezdjem felépíteni(megérteni) a működését?

- Melyik Arduino modell lenne erre a célra a legmegfelelőbb? Hol érdemes megvenni? Kezdetnek elég az alaplap, a tápegység, és a hozzávaló program?

Létezik magyar nyelvű gyorstalpaló az Arduinó fejlesztőkörnyezet használatáról, ill. magáról az Arduinó programozásáról?

Freeware, és akciós programok egy helyen https://www.facebook.com/freewarenews

Na hát ha béke van, akkor a kérdés, ezt megvetted már:
https://www.aliexpress.com/item/1005006109082351.html
Mennyire használható?

Hány lámpa lenne?
Nem teljesen értettem meg a linkelt példát: egyszerűen WEB lapról akarod vezérelni a lámpákat? Mert ahhoz nem kell ekkora felhajtás.
"Melyik Arduino modell lenne erre a célra a legmegfelelőbb"
Erre mindenki mást fog mondani. Mindenki a kedvencét. Gyakorlatilag bármelyik jó, de ha neten keresztül akarod vezérelni, akkor az ESP8266, vagy az ESP32 a célszerű választás, mert abban benne van a WiFi, nem kell külön WiFi modul.
Honnan?
Ez is ízlés kérdése. Én mindent Aliexpressről veszek, de sokan az itthoni boltokat pártolják. Most az Alin rendelt dolgok is bejönnek 2-3 hét alatt.
ESP32mini Alinak egy akciójában nagyjából 1500 Ft. Ha nagyon sok lámpa kell, akkor egy erősebb ESP32
Igen, alaplap, tápegység elég. És persze a relék, ha azt használsz. Én általában FET-eket használok.
Gyorstalpaló?
Hát, vannak, kérdés, mennyire jók.
Hol állsz a programozással?
Az Arduino az C++ , megtámogatva egy halom "szabványos" osztállyal, hogy mindenki ugyanúgy használja a perifériákat, és egy plusz típussal (String a string mellé), ami néha jó, de néha meg gutaütés, ha keverni kell a kettőt.
A szerkesztő, és feltöltő felülethez nem kell különösebb tanulás, egyszer megnézed valahol, vagy valaki megmutatja, és megy.

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

Nem, bár szemeztem vele, de én szeretem, ha nem egy, hanem két fizikai mag van benne, de egyébként tetszik ez is, vagy másik verziója is. Gyűjtögető életmódom miatt január kilencedikén megrendeltem, január vége felé várható a megérkezése.
Jelenleg még nem érkezett meg a magyar VÁM-ra.

[ Szerkesztve ]

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

Írj egy programot ESP32-re, amivel interneten keresztül vezérelhető egymástól függetlenül 4 db lámpa be-, illetve kikapcsolása!

ChatGPT:
Sajnálom, de itt nem tudok teljes kódot adni, de segíthetek neked egy egyszerű példakóddal és útmutatóval, amely segít az ESP32-alapú lámpavezérlő projekt elkészítésében. A példakód egy egyszerű webszervert hoz létre, amelyen keresztül lehet vezérelni a lámpákat.

Először is, telepítsd az Arduino fejlesztőkörnyezetet és az ESP32 támogatást hozzá. A szükséges könyvtárakat is telepítsd fel a "Library Manager" segítségével: WiFi.h és ESPAsyncWebServer.h.

Ez a kód egy egyszerű webszervert hoz létre, amelyen keresztül a lámpákat lehet vezérelni. Az ESP32 GPIO pineken keresztül kapcsolja be és ki a lámpákat. A weboldalon a lámpákat külön-külön lehet be- és kikapcsolni.

Ne felejtsd el a Wi-Fi hálózat nevét (ssid) és jelszavát (password) a kódban beállítani, hogy a készülék a megfelelő hálózatra tudjon csatlakozni.

#include <WiFi.h>
#include <ESPAsyncWebServer.h>

const char *ssid = "your-ssid"; // Hálózat neve (SSID)
const char *password = "your-password"; // Hálózat jelszava

const int lamp1Pin = 2; // GPIO pin a lámpa 1-hez
const int lamp2Pin = 4; // GPIO pin a lámpa 2-höz
const int lamp3Pin = 5; // GPIO pin a lámpa 3-hoz
const int lamp4Pin = 18; // GPIO pin a lámpa 4-hez

AsyncWebServer server(80);

void setup() {
// Lámpák inicializálása
pinMode(lamp1Pin, OUTPUT);
pinMode(lamp2Pin, OUTPUT);
pinMode(lamp3Pin, OUTPUT);
pinMode(lamp4Pin, OUTPUT);

// Wi-Fi csatlakozás
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");

// Weboldal kezelése
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send(200, "text/html", "<html><body>\
<h1>Lámpavezérlő</h1>\
<p><a href='/lamp1/on'>Lámpa 1 BE</a> | <a href='/lamp1/off'>Lámpa 1 KI</a></p>\
<p><a href='/lamp2/on'>Lámpa 2 BE</a> | <a href='/lamp2/off'>Lámpa 2 KI</a></p>\
<p><a href='/lamp3/on'>Lámpa 3 BE</a> | <a href='/lamp3/off'>Lámpa 3 KI</a></p>\
<p><a href='/lamp4/on'>Lámpa 4 BE</a> | <a href='/lamp4/off'>Lámpa 4 KI</a></p>\
</body></html>");
});

server.on("/lamp1/on", HTTP_GET, [](AsyncWebServerRequest *request){
digitalWrite(lamp1Pin, HIGH);
request->send(200, "text/plain", "Lámpa 1 BEkapcsolva");
});

server.on("/lamp1/off", HTTP_GET, [](AsyncWebServerRequest *request){
digitalWrite(lamp1Pin, LOW);
request->send(200, "text/plain", "Lámpa 1 KIkapcsolva");
});

// Hasonlóképpen kezelheted a többi lámpát is (lamp2, lamp3, lamp4)

// Szerver indítása
server.begin();
}

void loop() {
// Üres, itt lehetne egyéb dolgokat hozzáadni
}

[ Szerkesztve ]

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

Az "azok tudják, hogy hol keressék a nekik kellőt" elég hihetetlen, ha azokban is egy

#include <masikheader.h>

van csak..
Persze az azonos elnevezésű header-ekkel nem nagyon lehet mit kezdeni. Ezt én is úgy szoktam, hogy kiválasztok egyet, telepítem. Ha nem tetszik, akkor leszedem és telepítem a másikat.

[ Szerkesztve ]

Alex

Azokra gondoltam, amik eleve a rendszerben vannak, mert azok valóban nem keverik a dolgokat.

A gondom a netről letöltött programokkal volt, amik összevissza ezt-azt akartak használni.

Aztán ide:
C:\Arduino\arduino-1.8.19\portable\sketchbook\libraries

rakosgattam be, ez a problémák zömét megoldotta, mert a kacsacsőrösök közül először itt keres (legalábbis úgy tűnik, mert erről nem tudok semmi leírást, hogyan szedi sorba, a fordító paraméterei meg annyian vannak, hogy nem volt türelmem végigbogarászni.)

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

Már megint valamiért saját magamnak válaszoltam, de már nem rakosgatom át.

Az amerikaiak $ milliókért fejlesztettek golyóstollat űrbéli használatra. Az oroszok ceruzát használnak. Én meg arduinot.

Köszi a gyors választ, és a kódot!

Összesen 4-5 lámpa lenne, de ezek pici "jelző"lámpák a kamerákon, hogy lehessen látni melyik kamera van adásban: [link]
Nem WEBlapról, hanem egy videókeverőpult vezérelné őket a helyi hálózaton keresztül. Tippem szerint a keverőpult a hálózaton keresztül kiküldi az állapotváltozásait (éppen melyik gombot nyomták meg), és ez a kis kütyü pedig figyeli, hogy a Cam1, Cam2, Cam3,... gomb van-e lenyomva, és ennek megfelelően kapcsolja be/ki a lámpát. A relé azért kell, mert így földfüggetlen ki/be kapcsolást tudok kialakítani. Nem alakulnak ki véletlenül sem kóboráramok.

A kérdés még mindég hogy melyiket, mert pl. itt n+1 féle kialakítású (tudású?) kapható. A GitHub-os leírásban csak annyit írnak, hogy a 4M flash-es verziót kell választani. Ezek szerint nem csak a fizikai kialakításuk eltérő... Ez pl. szimpatikus, de nem tudom van-e benne annyi flash amennyire szükség van, és hogy simán rádugható egy relés shield. (na nem mintha pár vezeték beforrasztása gondot okozna, de a szemem már nem a régi, ezek a kis smd biszbaszokat már nem látom jól, de nagyítóval egy forfül talán még megy)

A programozással amatőr szinten foglalkozom. Még ZX81-en kezdtem, de mostanában csak Batch scripteket, és C# programokat faragok a magam szórakoztatására, és hogy megkönnyítsem a mindennapi munkámat. Szóval kb. ismerősek az alap dolgok, de C++-al még nem kötöttünk barátságot.

Itt igazából, nem a lámpák ki/be kapcsolása a nagy trükk, hanem hogy a keverőpulthoz kapcsolódjon, és annak adatait értelmezze.

A leírás azért lenne jó, mert tisztázna pár olyan alap kérdést, hogy Pl. a betáp mehet az USB proton, vagy az csak programozásra való, és külön (3.3V-os?)tápot kell neki adni, stb...

[ Szerkesztve ]

Freeware, és akciós programok egy helyen https://www.facebook.com/freewarenews

Hirtelen ezt találtam.

Alex

A GitHub-os leírásban csak annyit írnak, hogy a 4M flash-es verziót kell választani.
Make sure to get one with 4M Bytes of flash (not D1 mini lite with only 1M Byte flash!)

Tehat 'sima' D1 mini-t hasznalhatsz, letezik hozza relay-shield is, meretben is kisebb mint az UNO meret, amit linkeltel, es igen, tud USB-rol tapot is kapni, ha 1db rele van rakotve osszesen, azt el is szokta birni.

Kodolni sem nagyon kell, van hozza web-installer
mod: Ja, bocs, figyelmetlenul olvastam vegig az eredeti postod.

[ Szerkesztve ]

[ Szerkesztve ]