Keresés

Jóféle. 

https://www.microchip.com/design-centers/memory/serial-eeram

Természetesen a próbált kódba az értékadás is benne van csak azt nem másoltam be. Az értékadó sor:

ipptr = strtok(ipstr, ".");

az ok hogy valtozna, de attol meg a program jelenlegi allapotaban nincs erteke. tedd bele azt a reszt ami erteket ad neki, es jo lesz.

Sziasztok!

Adott az alábbi kód:

char* ipptr;
const char szamok[] = "0123456789";

int s;

s = strspn (ipptr,szamok);

lefordítva a következő hibát kapom a 4. sorra: "undefined reference to strspn"

Átírva az alábbira lefordul a kód ( const char* típusú argumentumot vár a strspn):

const char* ipptr = "sssss";
const char szamok[] = "0123456789";

int s;

s = strspn (ipptr,szamok);

Természetesen nekem az első változat kellene, hiszen a program futás közben változna  az ipptr által meghatározott char sztring.

A komplett kódot, melyből kiemeltem a fenti részletet windows console applikációban készítettem el és hiba nélkül fordítódott,

abból próbáltam átemelni arduino kódra, ahol az "undefined reference to strspn" hibát kaptam fordításkor.

Mi lehet a gond?

Ez új. Tudnál valami kapcsolási rajzot, vagy megvalósítást adni erről? 

> Ezt folyamatosan tárolni kellene EEPROM területen, hogy ne vesszen el, ezzel viszont hamar elérném az EEPROM véges írási ciklusát, szóval ez sem jó...

Erre való az EERAM. Folyamatosan írsz bele, nem kopik, mert SRAM. Amikor elmegy a táp, azt érzékeli, és egy kondiban tárolt energia segítségével beírja a SRAM tartalmát a tokon belüli EEPROM-ba.

Watchdog-ot megtaláltam. Nem tudtam, hogy eleve van benne. Mindenképpen beleteszem. 

Ott a pont tippért! Köszi! 

A 7805 nem melegszik, csak a Nano megy róla, a kimeneti driver IC nem sokat húz a kimeneteken. Persze a step-down a szép megoldás, de most így tesztre; jó lesz így. 

Zavarszűrés a tápnak? Vagy zavarszűrés a bemenetekre? Melyikre gondolsz? 

Nem terveztem bele watchdog-ot, mivel azt egy külső aktív elemnek kellene vinnie, pld. egy másik Ardu. És ha az fagy le? 

Ha van erre valamilyen konkrét megoldásod; mindenképp érdekelne! 

Áramszünet után a program az elejétől indul el. Ha onnan szeretném folytatni, ahol épp volt, akkor le kellene tárolnom EEPROM-ba egyrészt az összes kimenet értékét minden változáskor, valamint kellene egy programmutató, amit szintén. Ezt folyamatosan tárolni kellene EEPROM területen, hogy ne vesszen el, ezzel viszont hamar elérném az EEPROM véges írási ciklusát, szóval ez sem jó...

Köszi!

24V-->5V egy step-down nem lett volna jobb? Esélyes, hogy a 7805 durván melegedni fog. PLC-t zavarszűrés nélkül elég meredek dolog csinálni, pláne, ha kapcsolószekrénybe kerül.

Kis kínai Nano, nagy olasz Nano, nagy brit arm is le fog fagyni, ha úgy tartja kedve. És akkor lehet felmászni a létrán és resetet nyomkodni.

Az áramszüneti protokoll az, hogy áramkimaradás esetén hogyan tér vissza aktív állapotba, mit indít, ha programját honnan kezdi (ha kezdi egyáltalán).

Egyik sem "must have", de ettől függetlenül én hasznosnak találom ezeket a funkciókat, és felügyelet nélküli rendszerekbe integrálom is.

Hello, 

1, TD62783

2, Tápellátás kivülről 24V-os táp, belül 7805 az Arduino számára. Zavarszűrés még nincs, ez csak prototipus nyák. 

3, watchdog nincs. Kis kínai Nano nekem ne fagyjon le :-) Mire gondolsz az áramszüneti protokollal? 

Nem állítottam, hogy egyedülálló. De az enyém, mint a magyar narancs, még ha citromsárga, és savanyú is :-) 

Köszi a dícséretet! 

A kimeneti oldal most lett tesztelve, az megy, a driver IC dolgozik szépen. 

Szia!

Specifikus kérdéseim:
1. illesztést a kimenő oldalon milyen IC-vel oldod meg?
2. Tápellátás, zavarszűrés?

3. Watchdog? Áramszüneti protokoll?

Érdekes a koncepció, de nem egyedülálló. Csináltak hasonló elven az ipari PLC-k árának töredékéért hasonló termékeket, bár a tiédtől némileg eltérő programozási koncepcióval.

Egyébként igényesnek tűnik, gratulálok!

Nem tudom pontosan, hogy mi érdekel....

Ami a lényeg; régóta szerettem volna építeni egy olyan PLC-t, ami mikrovezérlő alapokon nyugszik, és a költségei töredéke egy gyári PLC-nek. 

Afféle "hobby" PLC-t, ami lehetőség szerint mindenben megegyezik a nagyokkal, de jóval olcsóbb. Otthoni automatizálásra, stb. 

Régebben PIC alapon próbáltam, de az nagyon bonyolult volt, nem sikerült a végéig jutni. 

Az Arduino sokkal kezesebb, és ha csak a saját nyelvén programozom is; majdnem a célnál vagyok. 

Persze a végső cél az, hogy létrában lehessen programozni, és belső működés tekintetében kövesse egy valódi PLC logikáját. 

Ehhez a PC alapú szoftver már kész, van egy általam írt PLC szimulátor, amelyet bővíteni szeretnék úgy, hogy az ott elkészített létra áttölthető legyen az Arduino-ba, és úgy fusson, mint az elvárható. 

Tehát nem HEX állományt gyártanék, hanem olyankódot, amit az Arduino-ban található (már kész) program tárol és feldolgoz, újra és újra végrehajt ciklikusan, ahogy kell. 

A PC szoftvert kell még bővíteni ezzel a tudással. 

Maga a NYÁK, amit a fotón látsz, tulajdonképpen egy 24V-ra illesztő shield. Optocsatolós bemenete van, és driver-IC-s kimenete. 

Ez méretre van tervezve egy olyan PLC-szerű dobozhoz, amit megadja a szükséges külsőt, C-sínre tehető, sorkapcsos csatlakozású.

https://www.tme.eu/hu/details/d3mg/din-sines-hazak/gainta/

Nagyjából ennyi. 

Engem érdekel, kérlek tegyél fel róla több infót! :)

Arduino-PLC.

Hamarosan jönnek a tesztek. Majd megírom. 

Köszönöm, úgy nézem az első lesz a befutó.

Habár a címzéssel úgy látom meg fogok küzdeni.

AVR-en az int 16 bit szokott lenni. Ha biztosra akarsz menni, akkor kerüld az intet, és használj helyette pontosan mindig ugyanakkora méretű változót, például uint16_t vagy ha kellenek negatív számok is, akkor int16_t.

Minden digitális memória legkisebb egysége a bit, amikből nyolc egy byte. Ezeket aztán platformtól függően lehet csoportokba szervezni. Az AVR egy 8 bites platform, így a memóriája bájtonként van struktúrálva. Mivel az int 16 bit, ezért két bájton fér el. Ezt a két bájtot kell külön elraknod az EEPROMba, majd visszaolvasni, és összerakni integerré. Többféle megoldás is létezik erre, leírok neked hármat.

1 Bitműveletek

16 bites adat két bájtja:

uint16_t data = 1976;

uint8_t dataLowByte = (uint8_t) ((data) & 0xff);

uint8_t dataHighByte = (uint8_t) ((data) >> 8);

Ezután az alsó és a felső bájtot már könnyen kiírod.

Visszafelé pedig a fordítottja:

uint8_t dataLowByte = EEPROM.read(addressLow);

uint8_t dataHighByte = EEPROM.read(addressHigh);

uint16_t data = (dataHighByte  << 8) | dataLowByte;

De az Arduinoban ezekre a gyakran használt műveletekre van makró is:

https://www.arduino.cc/reference/en/language/functions/bits-and-bytes/lowbyte/

https://www.arduino.cc/reference/en/language/functions/bits-and-bytes/highbyte/

https://www.arduino.cc/reference/en/language/variables/data-types/word/

2. union (Egy memóriaterület többféle értelmezése.)

union Data_t {

  uint16_t data16;

  uint8_t dataBytes[2];

}

Használata:

Data_t myData;

myData.data16 = 1979;

EEPROM.write(addressLow, dataBytes[0]);

EEPROM.write(addressHigh, dataBytes[1]);

3. Static cast (byte tömbként érelmezzük és használjuk a 16 bites elemekből álló tömböt az EEPROM műveletek során)

uint16_t data[16] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};

uint8_t *dataBytes = static_cast<uint8_t*>(static_cast<void*>(data));

//Írás:

for (int i = 0; i < 16 * 2; i++) {

  EEPROM.write(startAddress + i, dataBytes[i]);

}

//Olvasás:

for (int i = 0; i < 16 * 2; i++) {

  dataBytes[i] = EEPROM.read(startAddress + i);

}

Sziasztok!

I2c eeprom kezelésével megakadtam.

Szenzoradatokat rakok egy 16 elemű tömbbe ami integer típusú. Ezt írnám ki majd olvasnám az epromba/ból.

De nem találtam csak byte írására példát.

Az eeprom AT24C32. (256 page, 32byte).

Lécci segítsetek, köszönöm.

:-)))

A vibráció megszűnt. :-) 

Nos, átvariáltam a kódot, és megnöveltem a PWM frekvenciákat. 

Jelenleg nem látok vibrálást, de az esti "besötétedés" még hátra van. 

------------------------

#include <swRTC.h>
swRTC rtc;

const byte WhiteValue[60] = {255, 255, 255, 255, 255, 250, 245, 240, 235, 230, 225, 220, 215, 210, 205, 200, 195, 190, 185, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0};
const byte RedValue[60] = {190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 185, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0, 0, 0, 0, 0};
const byte BlueValue[60] = {190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 185, 180, 175, 170, 165, 160, 155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50};

byte WhitePin = 9;
byte RedPin = 10;
byte BluePin = 6;

byte PWM;
int hr;
int mins;

void setup()
{
rtc.stopRTC(); //stop the RTC
rtc.setTime(17, 55, 0); //set the time here
rtc.setDate(4, 1, 2018); //set the date here
rtc.startRTC(); //start the RTC
setPwmFrequency(9, 8); // (31250/8 = 3906 Hz)
setPwmFrequency(10, 8); // (31250/8 = 3906 Hz)
setPwmFrequency(6, 8); // (62500/8 = 7812 Hz)
}

void loop()
{
hr = rtc.getHours();
mins = rtc.getMinutes();

//Set White
if (hr <= 6) PWM = 0;
if (hr == 7) PWM = WhiteValue[59 - mins];
if (hr >= 8 && hr <= 20) PWM = 255;
if (hr == 21) PWM = WhiteValue[mins];
if (hr >= 22) PWM = 0;
analogWrite(WhitePin, PWM);

//Set Red
if (hr <= 5) PWM = 0;
if (hr == 6) PWM = RedValue[59 - mins];
if (hr >= 7 && hr <= 21) PWM = 190;
if (hr == 22)PWM = RedValue[mins];
if (hr >= 23) PWM = 0;
analogWrite(RedPin, PWM);

//Set Blue
if (hr <= 5) PWM = 50;
if (hr == 6) PWM = BlueValue[59 - mins];
if (hr >= 7 && hr <= 21) PWM =190;
if (hr == 22)PWM = BlueValue[mins];
if (hr >= 23) PWM = 50;
analogWrite(BluePin, PWM);
}

void setPwmFrequency(int pin, int divisor)
{
byte mode;
if (pin == 5 || pin == 6 || pin == 9 || pin == 10)
{
switch (divisor)
{
case 1: mode = 0x01; break;
case 8: mode = 0x02; break;
case 64: mode = 0x03; break;
case 256: mode = 0x04; break;
case 1024: mode = 0x05; break;
default: return;
}
if (pin == 5 || pin == 6)
{
TCCR0B = TCCR0B & 0b11111000 | mode;
} else
{
TCCR1B = TCCR1B & 0b11111000 | mode;
}
} else if (pin == 3 || pin == 11)
{
switch (divisor)
{
case 1: mode = 0x01; break;
case 8: mode = 0x02; break;
case 32: mode = 0x03; break;
case 64: mode = 0x04; break;
case 128: mode = 0x05; break;
case 256: mode = 0x06; break;
case 1024: mode = 0x07; break;
default: return;
}
TCCR2B = TCCR2B & 0b11111000 | mode;
}
}

Sajna nincs oszcilloszkópom... :-(

De amit megpróbálok; utánaolvastam a PWM frekvenciák állításának, és ma este megpróbálom más frekire átrakva a dolgot. 

Azután megírom, hogy mi lett a tapasztalat. 

Köszi! 

Azért csak rá kéne nézni egy oszcilloszkóppal.

A hivatalos oldal szerint ez (ha nem állítok be semmi egyebet), akkor ez 490 Hz környéke. 

Ez elég magas ahhoz, hogy ne lássam szemmel...

Interferálna valamivel? 

https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/

Valószínűleg azért villog, mert túl alacsony az alapbeállításhoz tartozó frekvencia.

Sehol. 

Alapbeállításokkal megy...

Hol állítod be a pwm frekvenciáját és működési módját?

Az elektromos probléma miatt a hobbielektronika.hu-t ajánlom megoldásra.

Sziasztok, 

Készítettem egy akvárium világítás vezérlést, ahol PWM-el szabályzom (IRF510-en keresztül) a LED szalagokat. 

Fehéret, pirosat, kéket. A célom az volt, hogy ne egyszerűen csak be-, vagy kikapcsoljanak a fények, hanem megfelelően dimmelve szimulálja a beesteledést, és a pirkadatot. 

Teljesen jól működik, de valamiért az egész zavaróan vibrál.... 

Tettem kondenzátorokat a kimenetekre, - és a bejövő tápra is, - valamelyest javult, de még mindig látni vélem a vibrálást....

Van rá valamilyen ötletetek? Találkoztatok ilyesmivel? Lehet, hogy a negyfrekvenciás terhelést nem szereti a táp? 

Itt a kód is, a piros és kék szineken van egy 0.75-ös szorzó, mert nem kell a teljes fénye, valamint a kék éjszakára 50-es értéken marad.

Köszi előre is! 

---------------------------------------

#include <swRTC.h>
swRTC rtc;

const byte Value[60] = {255,255,255,255,255,250,245,240,235,230,225,220,215,210,205,200,195,190,185,180,175,170,165,160,155,150,145,140,135,130,125,120,115,110,105,100,95,90,85,80,75,70,65,60,55,50,45,40,35,30,25,20,15,10,5,0,0,0,0,0};

byte WhitePin = 9;
byte RedPin = 10;
byte BluePin = 6;

byte PWM;
int hr;
int mins;
int sec;

void setup()
{
rtc.stopRTC(); //stop the RTC
rtc.setTime(20,40,0); //set the time here
rtc.setDate(2,1,2018); //set the date here
rtc.startRTC(); //start the RTC
}

void loop()
{
hr = rtc.getHours();
mins = rtc.getMinutes();

//Set White
if (hr <= 6) PWM = 0;
if (hr == 7) PWM = Value[59 - mins];
if (hr >= 8 && hr <= 20) PWM = 255;
if (hr == 21) PWM = Value[mins];
if (hr >= 22) PWM = 0;
analogWrite(WhitePin, PWM);

//Set Red
if (hr <= 5) PWM = 0;
if (hr == 6) PWM = Value[59 - mins] * 0.75;
if (hr >= 7 && hr <= 21) PWM = 255 * 0.75;
if (hr == 22)PWM = Value[mins] * 0.75;
if (hr >= 23) PWM = 0;
analogWrite(RedPin, PWM);

//Set Blue
if (hr <= 5) PWM = 0;
if (hr == 6) PWM = Value[59 - mins] * 0.75;
if (hr >= 7 && hr <= 21) PWM = 255 * 0.75;
if (hr == 22)PWM = Value[mins] * 0.75;
if (hr >= 23) PWM = 0;
if (PWM < 50) PWM = 50;
analogWrite(BluePin, 50);

delay(10000);

}

DUE-ra feltöltöttem, működik.

[code]
#include <DS3231.h>

int Relay0 = 13;
int Relay1 = 5;
int Relay2 = 6;
int Relay3 = 10;

DS3231 rtc(SDA, SCL);
Time t;

const int OnHour0 = 17;
const int OnMin0 = 30;
const int OffHour0 = 17;
const int OffMin0 = 31;
const int OnHour1 = 12;
const int OnMin1 = 26;
const int OffHour1 = 12;
const int OffMin1 = 27;

void setup() {
Serial.begin(115200);
rtc.begin();
pinMode(Relay0, OUTPUT);
digitalWrite(Relay0, LOW);
pinMode(Relay1, OUTPUT);
digitalWrite(Relay1, LOW);
pinMode(Relay2, OUTPUT);
digitalWrite(Relay2, LOW);
pinMode(Relay3, OUTPUT);
digitalWrite(Relay3, LOW);
}

void loop() {
t = rtc.getTime();
Serial.print(t.hour);
Serial.print(" hour(s), ");
Serial.print(t.min);
Serial.print(" minute(s)");
Serial.println(" ");
delay (1000);

if(t.hour == OnHour0 && t.min == OnMin0){
digitalWrite(Relay0,HIGH);
Serial.println("LIGHT ON");
}

else if(t.hour == OffHour0 && t.min == OffMin0){
digitalWrite(Relay0,LOW);
Serial.println("LIGHT OFF");
}
if(t.hour == OnHour1 && t.min == OnMin1){
digitalWrite(Relay1,HIGH);
Serial.println("LIGHT ON");
}

else if(t.hour == OffHour1 && t.min == OffMin1){
digitalWrite(Relay1,LOW);
Serial.println("LIGHT OFF");
}
}
[/code]