Elektriciteitskast controller
1 bericht
• Pagina 1 van 1
Elektriciteitskast controller
Controller voor een bestaande elektriciteitskast met impulsrelais (mijn eerste Arduino projectje ...)
Algemeen :
Mijn elektriciteitskast, centraal opgesteld op de 1e verdieping van de woning, heeft 25 enkelpolige impulsrelais waarmee de verlichting wordt geschakeld. Deze impulsrelais werken op 24VAC. De Arduino controller neemt de besturing van de impulsrelais voor zijn rekening. De bestaande installatie blijft behouden. Parallel met de drukknop(pen) komt een relaiskontakt die de impulsrelais aanstuurt. De controle van de toestand (aan/uit) wordt gedetecteerd door een 230VAC detection circuit.
Bij het commando ‘Lamp 1 aan’ komende van bijvoorbeeld een KaKu afstandsbediening of Nodo controller moet de in de elektriciteitskast aanwezige controller eerst de positie van de overeenstemmende impulsrelais controleren. Indien deze uit is, zal er een relais kortstondig sluiten en de impulsrelais laten schakelen. Is deze reeds aan dan mag er niets gebeuren.
Spanningsdetectie op impulsrelais :
Mijn elektriciteitskast heeft 25 enkelpolige impulsrelais waarmee mijn verlichting wordt geschakeld.
Deze impulsrelais werken op 24VAC. Om de toestand van deze impulsrelais te kennen, heb ik een soort van spanningsdetectie gemaakt. Streefdoel daarbij is geen bruggelijkrichters en elko’s te gebruiken.
Principe schema :
Werking van de schakeling :
De toegepaste opto coupler SFH620A-3X heeft intern 2 antiparallel ledjes. Elke nuldoorgang kan zeer eenvoudig gedetecteerd worden. De detectie verbruikt slechts een 0.18W per geactiveerde impulsrelais.
De bovenste opto coupler krijgt via 2 weerstanden continu 50Hz wisselspanning aangeboden.
De emittor van de opto coupler is verbonden met de Aa Schmitt trigger input van een monostabiele multivibrator MC14538. Deze wordt op een positief gaande flank getriggerd. De Q not output is verbonden met de clock ingang van een latch 74HCT574. Deze wordt getriggerd op een positieve flank. Wanneer we de tijdsconstante ongeveer 4ms maken, dan worden de latchen in het midden van elke positieve en negatieve alternantie van de wisselspanning geklokt.
Wanneer er een impulsrelais kontakt sluit, zal er op één van de ingangen van een 74HCT574 een spanningsverloop komen gelijk aan dat van de opto coupler die het referentiesignaal levert. De pulsen van de nuldoorgangen hebben geen effect omdat er steeds geklokt wordt in het midden van een alternatie. De signalen die op de uitgangen van de 74HCT574 latch verschijnen, zijn actief hoog.
In deze vorm kan de schakeling enkel gebruikt worden voor een enkelfazige aansluiting.
Op deze manier krijg ik 8 bits info die de toestand van mijn impulsrelais weergeeft. De uitgangen van een 74HCT574 latch hang ik aan Port1 van een I2C 16 bit I/O expander PCA9555D. Aan Port 0 van deze PCA9555D hangt een relaisbord met 8 relais.
Bij het schakelen van de deze impulsrelais worden er stoorpulsen gevormd waardoor het output register zijn initiële setup verliest. Er werd over elk relaiskontakt een condensator van 470nF/400V aangebracht.
Foto van de opstelling
Algemeen :
Mijn elektriciteitskast, centraal opgesteld op de 1e verdieping van de woning, heeft 25 enkelpolige impulsrelais waarmee de verlichting wordt geschakeld. Deze impulsrelais werken op 24VAC. De Arduino controller neemt de besturing van de impulsrelais voor zijn rekening. De bestaande installatie blijft behouden. Parallel met de drukknop(pen) komt een relaiskontakt die de impulsrelais aanstuurt. De controle van de toestand (aan/uit) wordt gedetecteerd door een 230VAC detection circuit.
Bij het commando ‘Lamp 1 aan’ komende van bijvoorbeeld een KaKu afstandsbediening of Nodo controller moet de in de elektriciteitskast aanwezige controller eerst de positie van de overeenstemmende impulsrelais controleren. Indien deze uit is, zal er een relais kortstondig sluiten en de impulsrelais laten schakelen. Is deze reeds aan dan mag er niets gebeuren.
Spanningsdetectie op impulsrelais :
Mijn elektriciteitskast heeft 25 enkelpolige impulsrelais waarmee mijn verlichting wordt geschakeld.
Deze impulsrelais werken op 24VAC. Om de toestand van deze impulsrelais te kennen, heb ik een soort van spanningsdetectie gemaakt. Streefdoel daarbij is geen bruggelijkrichters en elko’s te gebruiken.
Principe schema :
Werking van de schakeling :
De toegepaste opto coupler SFH620A-3X heeft intern 2 antiparallel ledjes. Elke nuldoorgang kan zeer eenvoudig gedetecteerd worden. De detectie verbruikt slechts een 0.18W per geactiveerde impulsrelais.
De bovenste opto coupler krijgt via 2 weerstanden continu 50Hz wisselspanning aangeboden.
De emittor van de opto coupler is verbonden met de Aa Schmitt trigger input van een monostabiele multivibrator MC14538. Deze wordt op een positief gaande flank getriggerd. De Q not output is verbonden met de clock ingang van een latch 74HCT574. Deze wordt getriggerd op een positieve flank. Wanneer we de tijdsconstante ongeveer 4ms maken, dan worden de latchen in het midden van elke positieve en negatieve alternantie van de wisselspanning geklokt.
Wanneer er een impulsrelais kontakt sluit, zal er op één van de ingangen van een 74HCT574 een spanningsverloop komen gelijk aan dat van de opto coupler die het referentiesignaal levert. De pulsen van de nuldoorgangen hebben geen effect omdat er steeds geklokt wordt in het midden van een alternatie. De signalen die op de uitgangen van de 74HCT574 latch verschijnen, zijn actief hoog.
In deze vorm kan de schakeling enkel gebruikt worden voor een enkelfazige aansluiting.
Op deze manier krijg ik 8 bits info die de toestand van mijn impulsrelais weergeeft. De uitgangen van een 74HCT574 latch hang ik aan Port1 van een I2C 16 bit I/O expander PCA9555D. Aan Port 0 van deze PCA9555D hangt een relaisbord met 8 relais.
Bij het schakelen van de deze impulsrelais worden er stoorpulsen gevormd waardoor het output register zijn initiële setup verliest. Er werd over elk relaiskontakt een condensator van 470nF/400V aangebracht.
Foto van de opstelling
- Code: Alles selecteren
/*
KaKu receiver to control 64 Pulsar pulse relays V1.05
--------------------------------------------------------
Input detection through opto-coupler (lights on or lights off).
Pulses to control the Pulsar pulse relays are made with relay contacts.
16 Inputs with 1x PCA9555D (I2C) addresses 0x20, 0x21, 0x22, 0x23.
16 Outputs with 1x PCA9555D (I2C) addresses 0x24, 0x25, 0x26, 0x27.
Arduino Mega2560 : SDA=20 ; SCL=21.
Arduino Pro Mini : SDA=A4 ; SCL=A5.
Receiver 433.9MHz is on pin 2 from the Arduino.
Serial monitoring possible on 115200 Baud.
In this example there are 32 on/off codes.
You can easily add more codes.
If the code is not in the case list, it will be displayed in the serial monitor.
Use 470nF on the relay contacts !
V1.04 : "All on/off" function implemented.
V1.04.01 : Working with Arduino Pro Mini.
V1.04.02 : Tuned for Hager EP513 pulse relays (100ms).
V1.04.03 : Delay after decoding otherwise problem with LCD remote control.
V1.04.04 : "All on/off" function is the 65th and 66th switch case.
V1.05 : Maskbyte implemented.
-----------------------------------------
| Download Remote Library from : |
| http://code.google.com/p/rc-switch/ |
-----------------------------------------
Dipswitches systemcode :
OFF = 1 (open contact)
ON = 0 (closed contact)
Examples dipswitch settings (left to right is switch 1 to switch 5) : ON ON ON ON ON = 00000 (00) In the commercial Kaku manual this is systemcode 12345.
OFF OFF OFF OFF OFF = 11111 (31) In the commercial Kaku manual this is systemcode 0.
ON OFF ON OFF ON = 01010 (10) In the commercial Kaku manual this is systemcode 135.
ON ON ON OFF OFF = 11100 (28) In the commercial Kaku manual this is systemcode 123.
These switch commands are the 'switch on' commands.
Switch off command is 'switch on + 3'
1361,4433,5201,5393, // 00000 00 (A, B, C, D)
17745,20817,21585,21777, // 00001 01 (A, B, C, D)
66897,69969,70737,70929, // 00010 02 (A, B, C, D)
83281,86353,87121,87313, // 00011 03 (A, B, C, D)
263505,266577,267345,267537, // 00100 04 (A, B, C, D)
279889,282961,283729,283921, // 00101 05 (A, B, C, D)
329041,332113,332881,333073, // 00110 06 (A, B, C, D)
345425,348497,349265,349457, // 00111 07 (A, B, C, D)
1049937,1053009,1053777,1053969, // 01000 08 (A, B, C, D)
1066321,1069393,1070161,1070353, // 01001 09 (A, B, C, D)
1115473,1118545,1119327,1119505, // 01010 10 (A, B, C, D)
1131857,1134929,1135697,1135889, // 01011 11 (A, B, C, D)
1312081,1315153,1315921,1316113, // 01100 12 (A, B, C, D)
1328465,1331537,1332305,1332497, // 01101 13 (A, B, C, D)
1377617,1380689,1381457,1381649, // 01110 14 (A, B, C, D)
1394001,1397073,1397841,1398033, // 01111 15 (A, B, C, D)
4195665,4198737,4199505,4199697, // 10000 16 (A, B, C, D)
4212049,4215121,4215889,4216081, // 10001 17 (A, B, C, D)
4261021,4264273,4265041,4265233, // 10010 18 (A, B, C, D)
4277585,4280657,4281425,4281617, // 10011 19 (A, B, C, D)
4457809,4460881,4461649,4461841, // 10100 20 (A, B, C, D)
4474193,4477265,4478033,4478225, // 10101 21 (A, B, C, D)
4523345,4526417,4527185,4527377, // 10111 22 (A, B, C, D)
4539729,4542801,4543569,4543761, // 10111 23 (A, B, C, D)
5244241,5247313,5248081,5248273, // 11000 24 (A, B, C, D)
5260625,5263697,5264465,5264657, // 11001 25 (A, B, C, D)
5309777,5312849,5313617,5313809, // 11010 26 (A, B, C, D)
5326161,5329233,5330001,5330193, // 11011 27 (A, B, C, D)
5506385,5509457,5510225,5510417, // 11100 28 (A, B, C, D)
5522769,5525841,5526609,5526801, // 11101 29 (A, B, C, D)
5571921,5574993,5575761,5575953, // 01111 30 (A, B, C, D)
5588305,5591377,5592145,5592337, // 11111 31 (A, B, C, D)
by on1bte 07/2014
*/
int Maskbyte[] = {B00000000,B00000000,B00000000,B11111110};
// 0 = no masking , 1 = masking
// In8,In7,In6,In5,In4,In3,In2,In1 In16,In15,In14,In13,In12,In11,In10,In9 In24,In23,In22,In21,In20,In19,In18,In17 In32,In31,In30,In29,In28,In27,In26,In25
unsigned long Code;
int Interface = 4; // Amount of PCA9555D chips. To control 16 Pulsar relays you need 2 times PCA9555D. The first 16 inputs are on the first PCA9555D on address 0x20.
// The first 16 outputs are on address 0x24. The second 16 inputs are on 0x21, the second 16 outputs on 0x25, ...
int PulseDuration = 100; // Pulseduration. Put this between 75 and 300ms
byte RData = 0x00; // initial value Remote Data
byte In = 0x00; // initial value Optocoupler board data
byte OnOff = 0x00; // initial value OnOff bit
byte Pulse = 0x00; // initial value Pulse bit
byte Bit = 0x00; // initial value for Bit
byte Board = 0x00; // initial value for Board
byte Port = 0x00; // initial value for Port
byte Pin = 0x01; // initial value for Pin
#define PCA9555 0x20 // 1st PCA9555D on adress 0x20
#define IN_P0 0x00 // Register 0 : Input port register Port 0
#define IN_P1 0x01 // Register 1 : Input port register Port 1
#define OUT_P0 0x02 // Register 2 : Output port register Port 0
#define OUT_P1 0x03 // Register 3 : Output port register Port 1
#define INV_P0 0x04 // Register 4 : Polarity Inversion register Port 0 --> 1 = polarty inverted , 0 = polarity retained
#define INV_P1 0x05 // Register 5 : Polarity Inversion register Port 1 --> 1 = polarty inverted , 0 = polarity retained
#define CONFIG_P0 0x06 // Register 6 : Configuration register Port 0 --> 1 = input , 0 = output (high value resistor tied to VDD at each pin)
#define CONFIG_P1 0x07 // Register 7 : Configuration register Port 1 --> 1 = input , 0 = output
#define PAUSE 250
#include <Wire.h>
#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();
void setup() {
Serial.begin(115200);
mySwitch.enableReceive(0); // Receiver on interrupt 0 => that is pin #2
Wire.begin();
for(int i =0; i < Interface/2; i++){
Board = i;
write_io (CONFIG_P0, B11111111); // Configure Port 0 all input
write_io (INV_P0, B00000000); // Set Port 0 Bit polarity
write_io (CONFIG_P1, B11111111); // Configure Port 1 all input
write_io (INV_P1, B00000000); // Set Port 1 Bit polarity
delay (PAUSE);
}
for(int i =0; i < Interface/2; i++){
Board = i + 4;
write_io (CONFIG_P0, B00000000); // Configure Port 0 all output
write_io (OUT_P0, B11111111); // Set Port 0 All Bits High
write_io (CONFIG_P1, B00000000); // Configure Port 1 all output
write_io (OUT_P1, B11111111); // Set Port 1 All Bits High
}
}
void loop() {
if (mySwitch.available()) {
int value = mySwitch.getReceivedValue();
if (value == 0) {
Serial.print("Unknown encoding");
} else {
Code = mySwitch.getReceivedValue();
switch (Code) {
case 1394001:
Serial.println("15A^");
RData = 0x01; RemoteSwitching();
break;
case 1394004:
Serial.println("15A_");
RData = 0x00; RemoteSwitching();
break;
case 1397073:
Serial.println("15B^");
RData = 0x03; RemoteSwitching();
break;
case 1397076:
Serial.println("15B_");
RData = 0x02; RemoteSwitching();
break;
case 1397841:
Serial.println("15C^");
RData = 0x05; RemoteSwitching();
break;
case 1397844:
Serial.println("15C_");
RData = 0x04; RemoteSwitching();
break;
case 1398033:
Serial.println("15D^");
RData = 0x07; RemoteSwitching();
break;
case 1398036:
Serial.println("15D_");
RData = 0x06; RemoteSwitching();
break;
case 4539729:
Serial.println("23A^");
RData = 0x09; RemoteSwitching();
break;
case 4539732:
Serial.println("23A_");
RData = 0x08; RemoteSwitching();
break;
case 4542801:
Serial.println("23B^");
RData = 0x0B; RemoteSwitching();
break;
case 4542804:
Serial.println("23B_");
RData = 0x0A; RemoteSwitching();
break;
case 4543569:
Serial.println("23C^");
RData = 0x0D; RemoteSwitching();
break;
case 4543572:
Serial.println("23C_");
RData = 0x0C; RemoteSwitching();
break;
case 4543761:
Serial.println("23D^");
RData = 0x0F; RemoteSwitching();
break;
case 4543764:
Serial.println("23D_");
RData = 0x0E; RemoteSwitching();
break;
case 5326161:
Serial.println("27A^");
RData = 0x11; RemoteSwitching();
break;
case 5326164:
Serial.println("27A_");
RData = 0x10; RemoteSwitching();
break;
case 5329233:
Serial.println("27B^");
RData = 0x13; RemoteSwitching();
break;
case 5329236:
Serial.println("27B_");
RData = 0x12; RemoteSwitching();
break;
case 5330001:
Serial.println("27C^");
RData = 0x15; RemoteSwitching();
break;
case 5330004:
Serial.println("27C_");
RData = 0x14; RemoteSwitching();
break;
case 5330193:
Serial.println("27D^");
RData = 0x17; RemoteSwitching();
break;
case 5330196:
Serial.println("27D_");
RData = 0x16; RemoteSwitching();
break;
case 5522769:
Serial.println("29A^");
RData = 0x19; RemoteSwitching();
break;
case 5522772:
Serial.println("29A_");
RData = 0x18; RemoteSwitching();
break;
case 5525841:
Serial.println("29B^");
RData = 0x1B; RemoteSwitching();
break;
case 5525844:
Serial.println("29B_");
RData = 0x1A; RemoteSwitching();
break;
case 5526609:
Serial.println("29C^");
RData = 0x1D; RemoteSwitching();
break;
case 5526612:
Serial.println("29C_");
RData = 0x1C; RemoteSwitching();
break;
case 5526801:
Serial.println("29D^");
RData = 0x1F; RemoteSwitching();
break;
case 5526804:
Serial.println("29D_");
RData = 0x1E; RemoteSwitching();
break;
case 5571921:
Serial.println("30A^");
RData = 0x21; RemoteSwitching();
break;
case 5571924:
Serial.println("30A_");
RData = 0x20; RemoteSwitching();
break;
case 5574993:
Serial.println("30B^");
RData = 0x23; RemoteSwitching();
break;
case 5574996:
Serial.println("30B_");
RData = 0x022; RemoteSwitching();
break;
case 5575761:
Serial.println("30C^");
RData = 0x25; RemoteSwitching();
break;
case 5575764:
Serial.println("30C_");
RData = 0x24; RemoteSwitching();
break;
case 5575953:
Serial.println("30D^");
RData = 0x27; RemoteSwitching();
break;
case 5575956:
Serial.println("30D_");
RData = 0x26; RemoteSwitching();
break;
case 345425:
Serial.println("07A^");
RData = 0x29; RemoteSwitching();
break;
case 345428:
Serial.println("07A_");
RData = 0x28; RemoteSwitching();
break;
case 348497:
Serial.println("07B^");
RData = 0x2B; RemoteSwitching();
break;
case 348500:
Serial.println("07B_");
RData = 0x2A; RemoteSwitching();
break;
case 349265:
Serial.println("07C^");
RData = 0x2D; RemoteSwitching();
break;
case 349268:
Serial.println("07C_");
RData = 0x2C; RemoteSwitching();
break;
case 349457:
Serial.println("07^");
RData = 0x2F; RemoteSwitching();
break;
case 349460:
Serial.println("07D_");
RData = 0x2E; RemoteSwitching();
break;
case 1131857:
Serial.println("11A^");
RData = 0x31; RemoteSwitching();
break;
case 1131860:
Serial.println("11A_");
RData = 0x30; RemoteSwitching();
break;
case 1134929:
Serial.println("11B^");
RData = 0x33; RemoteSwitching();
break;
case 1134932:
Serial.println("11B_");
RData = 0x32; RemoteSwitching();
break;
case 1135697:
Serial.println("11C^");
RData = 0x35; RemoteSwitching();
break;
case 1135700:
Serial.println("11C_");
RData = 0x34; RemoteSwitching();
break;
case 1135889:
Serial.println("11D^");
RData = 0x37; RemoteSwitching();
break;
case 1135892:
Serial.println("11D_");
RData = 0x36; RemoteSwitching();
break;
case 1328465:
Serial.println("13A^");
RData = 0x39; RemoteSwitching();
break;
case 1328468:
Serial.println("13A_");
RData = 0x38; RemoteSwitching();
break;
case 1331537:
Serial.println("13B^");
RData = 0x3B; RemoteSwitching();
break;
case 1331540:
Serial.println("13B_");
RData = 0x3A; RemoteSwitching();
break;
case 1332305:
Serial.println("13C^");
RData = 0x3D; RemoteSwitching();
break;
case 1332308:
Serial.println("13C_");
RData = 0x3C; RemoteSwitching();
break;
case 1332497:
Serial.println("13D^");
RData = 0x3F; RemoteSwitching();
break;
case 1332500:
Serial.println("13D_");
RData = 0x3E; RemoteSwitching();
break;
case 1115473:
Serial.println("10A^");
RData = 0x01; all_on_off();
break;
case 1115476:
Serial.println("10A_");
RData = 0x00; all_on_off();
break;
default:
// no valid code for this system :
Serial.print("Received Code = ");
Serial.println(Code);
Serial.println("-----------------------");
}
delay (200); // necessary !!!
mySwitch.resetAvailable();
}
}
}
void RemoteSwitching() {
Serial.print("RData = ");
Serial.println(RData, BIN);
Bit = RData >>1 & 0x07; // Shift one to the right AND 0x07 gives the Output pin
Pin = B00000001 << Bit; // Shift left to the correct bit position
OnOff = RData & 0x01; // OnOff data is the least significant bit from RData
OnOff = OnOff << Bit; // Bring OnOff bit to the same bitposition as the Pin to be used
Port = RData >> 4 & 0x01; // Shift 4 times to the right AND 0x01 gives the port selection data
Board = RData >> 5 & 0x07; // Shift 5 times to the right AND 0x07 gives the Board selection data
Serial.print("Bit = ");
Serial.println(Bit);
Serial.print("Pin = ");
Serial.println(Pin, BIN);
Serial.print("OnOff = ");
Serial.println(OnOff, BIN);
Serial.print("Port = ");
Serial.println(Port, BIN);
Serial.print("Board = ");
Serial.println(Board, BIN);
read_io(); // Go to subroutine read_io
In = In & Pin; // Select only the pin to be activated - Input Data AND Pin
Serial.print("In = "); Serial.println(In, BIN);
if (OnOff == In)
{
Serial.println("OnOff and In =="); Pulse = 0xFF; // OnOff In equal? --> No action
}
else
{
Serial.println("OnOff and In xx"); Pulse = ~Pin; // OnOff In not equal? --> the byte Pin is inverted and renamed to Pulse
}
Serial.print("Pulse = ");
Serial.println(Pulse, BIN);
Board = Board + 4;
// Reinitialisation output register before and after a write. Pulsar Relays can cause a lot of interferences
write_io (CONFIG_P0, B00000000); // Configure Port 0 all output
write_io (OUT_P0, B11111111); // Set Port 1 all bits high
write_io (CONFIG_P1, B00000000); // Configure Port 0 all output
write_io (OUT_P1, B11111111); // Set Port 1 all bits high
write_io (OUT_P0 + Port, Pulse); // Go the subroutine write_io
delay (PulseDuration); // Output pin stays low for a while
write_io (OUT_P0 + Port, B11111111); // All output pins High
write_io (CONFIG_P0, B00000000); // Configure Port 0 all output
write_io (OUT_P0, B11111111); // Set Port 1 all bits high
write_io (CONFIG_P1, B00000000); // Configure Port 0 all output
write_io (OUT_P1, B11111111); // Set Port 1 all bits high
Serial.println("-------------------------");
}
void write_io(int command, int value)
{
Wire.beginTransmission(PCA9555 + Board); // write to PCA9555 + Board
Wire.write(command),Wire.write(value);
Wire.endTransmission();
}
void read_io()
{
Wire.beginTransmission(PCA9555 + Board);
Wire.write(IN_P0 + Port); // must act as a position pointer
Wire.endTransmission();
Wire.requestFrom(PCA9555 + Board, 1); // request 1 byte
In = Wire.read(); // receive a byte
}
void all_on_off()
{
for(int i =0; i < Interface/2; i++){
Board = i;
Serial.print("Board = ");
Serial.println(Board, BIN);
for(Port =0; Port < 2; Port++){
Serial.print("Port = ");
Serial.println(Port, BIN);
read_io();
Serial.print("In = "); Serial.println(In, BIN);
int Mask = 2*Board + Port; // select Maskbyte
Serial.print("Mask = "); Serial.println(Mask, BIN);
Serial.print("Maskbyte = "); Serial.println(Maskbyte[Mask], BIN);
OnOff = RData & 0x01; // OnOff data is the least significant bit from RData
Serial.print("OnOff = ");
Serial.println(OnOff, BIN);
if (OnOff == 1)
{
Serial.println("All^"); Pulse = In | Maskbyte[Mask]; // all on (taking maskbyte into account)
}
else
{
Serial.println("All_"); Pulse = ~In | Maskbyte[Mask]; // all off (taking Maskbyte into account)
}
Serial.print("Pulse = ");
Serial.println(Pulse, BIN);
Board = Board + 4;
// Reinitialisation output register before and after a write. Pulsar Relays can cause a lot of interferences
write_io (CONFIG_P0, B00000000); // Configure Port 0 all output
write_io (OUT_P0, B11111111); // Set Port 1 all bits high
write_io (CONFIG_P1, B00000000); // Configure Port 0 all output
write_io (OUT_P1, B11111111); // Set Port 1 all bits high
write_io (OUT_P0 + Port, Pulse); // Go the subroutine write_io
delay (PulseDuration); // Output pin stays low for a while
write_io (OUT_P0 + Port, B11111111); // All output pins High
write_io (CONFIG_P0, B00000000); // Configure Port 0 all output
write_io (OUT_P0, B11111111); // Set Port 1 all bits high
write_io (CONFIG_P1, B00000000); // Configure Port 0 all output
write_io (OUT_P1, B11111111); // Set Port 1 all bits high
Board = Board - 4;
delay (PAUSE);
Serial.println("-------------------------");
}
}
}
Advertisement
1 bericht
• Pagina 1 van 1
Terug naar Afgeronde projecten
Wie is er online?
Gebruikers in dit forum: Geen geregistreerde gebruikers en 5 gasten