Hallo zusammen,
ich verwende einen Arduino MEGA mit einem RS232 Shield um eine serielle Kommunikation mit einem speziellen Lampenhaus herzustellen.
Hier mein Problem.
Die Kommunikation zwischen einem Terminal und dem Lampenhaus funktioniert.
In diesem Fall wird der Terminal als Arduino simuliert der das Kommando versendet.
Die Kommunikation zwischen einem Terminal und dem Arduino funktioniert.
In diesem Fall wird der Terminal als Lampenhaus simuliert der das Kommando empfangen soll.
Aber die Kommunikation zwischen dem Arduino und dem Lampenhaus direkt leider nicht.
Wenn der Arduino ein Kommando zum Lampenhaus versendet akzeptiert dieser das Kommando nicht.
Es kommt keine Fehlermeldung zurück.
Hier der Ausschnitt aus dem Programm:
#include <LiquidCrystal.h>
//Display
LiquidCrystal lcd(49, 48, 41, 40, 39, 38);
//Intensity
byte in_inten_up=30;
byte in_inten_down=31;
int in_analog_inten=0;
byte out_inten_max=28;
byte out_inten_min=29;
byte out_inten_up=22;
byte out_inten_down=23;
int inten_max=500;
int inten_min=230;
int inten_time=250; //time between pulses for intensity 1->1 ms
//Filter
byte in_filter_a=32;
byte in_filter_b=33;
byte in_filter_c=34;
byte out_filter_a=24;
byte out_filter_b=25;
byte out_filter_c=26;
//Lamp
byte in_lamp_on=35;
byte out_lamp_stable=27;
byte in_cool_lamp=36;
byte out_lamp_change=21;
unsigned long lamp_stable_time=7; //lamp stable time 1->1 sec
unsigned long anzeige=0;
unsigned long interval=1000;
unsigned long savemillis=0;
long lamp_hours=0;
bool lamp_on;
bool lamp_off;
bool cool_lamp;
//Shutter
byte in_shutter_open=37;
//RS232
char rx_data[8];
char rx_lamp[6];
int rx_counter=0;
bool rx_finish=LOW;
unsigned long savemillisrs232=0;
unsigned long intervalrs232=5000; //interval for lamphours check 1->1 ms
bool program_start=LOW;
bool run_ready=LOW;
void setup()
{
//serial start
Serial.begin(19200);
//RS232 serial start
Serial1.begin(19200);
//Display starten
lcd.begin(16, 2);
//Intensity up
pinMode(in_inten_up, INPUT);
pinMode(out_inten_up, OUTPUT);
pinMode(out_inten_max, OUTPUT);
digitalWrite(out_inten_max, LOW);
digitalWrite(out_inten_min, LOW);
//Intensity down
pinMode(in_inten_down, INPUT);
pinMode(out_inten_down, OUTPUT);
pinMode(out_inten_min, OUTPUT);
//Filter A
pinMode(in_filter_a, INPUT);
pinMode(out_filter_a, OUTPUT);
//Filter B
pinMode(in_filter_b, INPUT);
pinMode(out_filter_b, OUTPUT);
//Filter C
pinMode(in_filter_c, INPUT);
pinMode(out_filter_c, OUTPUT);
//Lamp
pinMode(in_lamp_on, INPUT);
pinMode(out_lamp_stable, OUTPUT);
pinMode(in_cool_lamp, INPUT);
digitalWrite(out_lamp_stable, LOW);
//Shutter
pinMode(in_shutter_open, INPUT);
}
void loop()
{
if(program_start==LOW)
{
Serial.println("Program start");
lcd.setCursor(0,0);
lcd.print("Program start");
delay(2000);
RS232sendconnect();
RS232receiveconnect();
program_start=HIGH;
}
if(run_ready==HIGH)
{
if(digitalRead(in_lamp_on)==HIGH)
{
if(lamp_on==LOW)
{
Serial.println("lamp is on");
lcd.clear();
lcd.setCursor(0,0);
lcd.print("lamp is on");
cool_lamp=LOW;
delay(2000);
}
lamp_on=HIGH;
lamp_off=LOW;
lamp_stable();
}
if(digitalRead(in_lamp_on)==LOW)
{
if(lamp_off==LOW)
{
Serial.println("lamp is off");
lcd.clear();
lcd.setCursor(0,0);
lcd.print("lamp is off");
anzeige=0;
}
lamp_on=LOW;
lamp_off=HIGH;
digitalWrite(out_lamp_stable, LOW);
}
if(digitalRead(out_lamp_stable)==HIGH)
{
intensity_up_down();
}
if(digitalRead(in_cool_lamp)==HIGH&&cool_lamp==LOW)
{
Serial.println("lamp has to be cool down");
cool_lamp=HIGH;
}
filter();
if(millis()-savemillisrs232>intervalrs232)
{
RS232gethours();
}
}
}
void lamp_stable()
{
if(digitalRead(out_lamp_stable)==HIGH)
{
if(millis()-savemillis>interval)
{
savemillis=millis();
anzeige=anzeige+1;
Serial.print("lamp ready in: ");
lcd.setCursor(0,1);
lcd.print("warm-up lamp");
Serial.print(lamp_stable_time-anzeige);
Serial.println(" sec.");
if(anzeige==lamp_stable_time)
{
Serial.println("lamp is stable");
lcd.clear();
lcd.setCursor(0,0);
lcd.print("lamp is stable");
lcd.setCursor(0,1);
lcd.print("lamphours: ");
lcd.print(lamp_hours);
digitalWrite(out_lamp_stable, HIGH);
}
}
}
if(anzeige<lamp_stable_time)
{
digitalWrite(out_lamp_stable, LOW);
}
}
void filter()
{
//Filter A
if(digitalRead(in_filter_a)==LOW)
{
digitalWrite(out_filter_a, LOW);
}
if(digitalRead(in_filter_a)==HIGH)
{
digitalWrite(out_filter_a, HIGH);
}
//Filter B
if(digitalRead(in_filter_b)==LOW)
{
digitalWrite(out_filter_b, LOW);
}
if(digitalRead(in_filter_b)==HIGH)
{
digitalWrite(out_filter_b, HIGH);
}
//Filter C
if(digitalRead(in_filter_c)==LOW)
{
digitalWrite(out_filter_c, LOW);
}
if(digitalRead(in_filter_c)==HIGH)
{
digitalWrite(out_filter_c, HIGH);
}
}
void intensity_up_down()
{
//Intensity up
if(digitalRead(in_inten_up)==LOW&&digitalRead(in_shutter_open)==HIGH)
{
digitalWrite(out_inten_up, LOW);
delay(inten_time);
Serial.println("up");
digitalWrite(out_inten_up, HIGH);
delay(inten_time);
intensity_measurment();
}
if(digitalRead(in_inten_up)==HIGH)
{
digitalWrite(out_inten_up, HIGH);
}
//Intensity down
if(digitalRead(in_inten_down)==LOW&&digitalRead(in_shutter_open)==HIGH)
{
digitalWrite(out_inten_down, LOW);
delay(inten_time);
Serial.println("down");
digitalWrite(out_inten_down, HIGH);
delay(inten_time);
intensity_measurment();
}
if(digitalRead(in_inten_down)==HIGH)
{
digitalWrite(out_inten_down, HIGH);
}
}
void intensity_measurment()
{
in_analog_inten=analogRead(A15);
Serial.println(in_analog_inten);
if(in_analog_inten>inten_max)
{
digitalWrite(out_inten_max, LOW);
Serial.println("intensity max");
}
if(in_analog_inten<inten_min)
{
digitalWrite(out_inten_min, LOW);
Serial.println("intensity min");
}
if(in_analog_inten>inten_min&&in_analog_inten<inten_max)
{
digitalWrite(out_inten_min, HIGH);
digitalWrite(out_inten_max, HIGH);
}
}
void RS232sendconnect()
{
Serial1.print("CONN18");
Serial1.print('\r');
Serial.println("begin RS232 communication");
}
void RS232receiveconnect()
{
while(strcmp(rx_data, "READY0A")!=0)
{
if(Serial1.available())
{
rx_data[rx_counter]=Serial1.read();
Serial.println(rx_data);
rx_counter++;
}
}
if(strcmp(rx_data, "READY0A")==0)
{
Serial.println("connected to OMNICURE");
run_ready=HIGH;
rx_counter=0;
Serial1.end();
delay(2000);
}
}
void RS232gethours()
{
Serial1.begin(19200);
Serial1.write("GLH19\r");
Serial.println("wait to get lamp hours");
rx_finish=LOW;
RS232receivehours();
}
void RS232receivehours()
{
while(rx_finish==LOW)
{
if(Serial1.available())
{
rx_data[rx_counter]=Serial1.read();
rx_counter++;
}
if(rx_counter==7)
{
rx_lamp[0]=rx_data[0];
rx_lamp[1]=rx_data[1];
rx_lamp[2]=rx_data[2];
rx_lamp[3]=rx_data[3];
rx_lamp[4]=rx_data[4];
lamp_hours=atol(rx_lamp);
Serial.print(lamp_hours-32768-16384); //-Bit 15, -Bit 14
Serial.print(" lamphours");
Serial.print('\n');
rx_counter=0;
savemillisrs232=millis();
rx_finish=HIGH;
Serial1.end();
}
}
}
Ich vermute mal das der Code richtig ist. Ein Kollege von mir meint das es an der Taktfrequenz vom Arduino liegen könnte.
Das Kommando wird in der Funktion rs232sendconnect versendet.
LG