UART Funktioniert nicht wenn PWM Aktiv ist (Bascom)

[Peter K. (pker)]

Hallo!

Habe hier ein Problem bei meiner Lüftersteuerung.

Die Steuerung sammelt Temperaturdaten, Drehzahldaten vom Lüfter und 
regelt diese.

Soweit funktioniert auch alles aber die Ausgabe über die UART 
Schnittstelle funktioniert nicht wenn ich zb. compare1a=150 einstelle.

Schaltplan im Anhang.

Und hier der Code:

Siehe Abschnitt "Lüfter regeln" und "Ausgabe über UART"

'###############################################################################
'Lüftersteuerung v1.0 @ P.K.er
'###############################################################################
$regfile = "m8def.dat"
$crystal = 8000000
$baud = 19200


'ADC Config'####################################################################
Config Adc = Single , Prescaler = Auto , Reference = Avcc
Start Adc


'Port Config'###################################################################
Config Portb.1 = Output                                     'fan1 PWM

Config Portd.2 = Output                                     'fan2 PWM

Config Pind.2 = Input                                       'fan1 INT
Portd.2 = 1

Config Pind.3 = Input                                       'fan2 INT
Portd.3 = 1


'Timer, PWM und Interupts##########################################
Config Timer0 = Timer , Prescale = 1024                     'timer für zeit erfassung
On Timer0 Isr_timer0
Enable Timer0

Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1       'timer für pwm lüfter

Config Int0 = Falling
Config Int1 = Falling
On Int0 Isr_int0
On Int1 Isr_int1
Enable Int0
Enable Int1
Enable Interrupts

'Variablen für Drehzahlerfassung'##########################################################
Dim Rpm1 As Word
Dim Rpm2 As Word
Dim Rpm1_temp As Word
Dim Rpm2_temp As Word
Dim X As Byte
Dim Soft_timer As Byte
Dim Rpm_runden As Byte
Dim Rpm_runden1 As Word
Dim Rpm_runden2 As Word

'Variablen für Lüfterregelung'#######################################################
Dim Pwm01 As Single
Dim Pwm02 As Single
Dim Min_temp1 As Single
Dim Soll_temp1 As Single
Dim Min_temp2 As Single
Dim Soll_temp2 As Single

'CPU
Min_temp1 = 45                                              'unterer Temperaturwert

Soll_temp1 = 50                                             'Oberer temperaturwert

'Umgebung
Min_temp2 = 30                                              'unterer Temperaturwert

Soll_temp2 = 35                                             'Oberer temperaturwert



'Variablen für Temperaturmessung'###################################################
Dim Wert1 As Single
Dim Mittel_wert1 As Single
Dim Temp1 As Single
Dim Raw1 As Word
Dim Wert2 As Single
Dim Mittel_wert2 As Single
Dim Temp2 As Single
Dim Raw2 As Word

Dim A As Byte
A = 0

Dim Uref As Single                                          'Referencespannung
Uref = 5.12


'Variablen für Ausgabe##########################################################
Dim Temp1_str As String * 5
Dim Temp2_str As String * 5
Dim Rpm1_str As Word
Dim Rpm2_str As Word
Dim Zeit As Byte
Dim Pwm01_str As Word
Dim Pwm02_str As Word


'Hauptprogramm##################################################################
Do
Zeit = Zeit + 1

'Temperaturdaten holen##########################################################

'Temperatur in Grad = ((ADC x Avcc) / 1024) x 100) - 273.1

   Raw1 = Getadc(0)
   Waitms 20
   Temp1 = Raw1 * Uref
   Temp1 = Temp1 / 1024
   Temp1 = Temp1 * 100
   Temp1 = Temp1 - 273.15


   Raw2 = Getadc(1)
   Waitms 20
   Temp2 = Raw2 * Uref
   Temp2 = Temp2 / 1024
   Temp2 = Temp2 * 100
   Temp2 = Temp2 - 273.15

   A = A + 1

   Mittel_wert1 = Mittel_wert1 + Temp1

   Mittel_wert2 = Mittel_wert2 + Temp2

   If A = 20 Then

      A = 0

      Wert1 = Mittel_wert1 / 20
      Wert2 = Mittel_wert2 / 20

      Wert1 = Wert1 - 4
      Wert2 = Wert2 - 4

      Mittel_wert1 = 0
      Mittel_wert2 = 0

      Temp1_str = Fusing(wert1 , "#.#")

      Temp2_str = Fusing(wert2 , "#.#")


   End If

'Lüfter regeln##################################################################

Compare1a = 150
Compare1b = 150

Wait 5

Compare1a = 255
Compare1b = 255

Wait 5

'Drehzahlerfassung##############################################################
If X = 1 Then
   X = 0

   'rpm werte runden
   Rpm_runden1 = Rpm_runden1 + Rpm1
   Rpm_runden2 = Rpm_runden2 + Rpm2

   Rpm_runden = Rpm_runden + 1

   If Rpm_runden = 5 Then

      Rpm1 = Rpm_runden1 / 5
      Rpm2 = Rpm_runden2 / 5

      Rpm_runden1 = 0
      Rpm_runden2 = 0

      Rpm_runden = 0

      'rpm werte berechnen
      Rpm1_str = Rpm1 * 30                                  'rpm * 30sek. (weil 2 imputse pro umdrehung)
      Rpm2_str = Rpm2 * 30                                  'rpm * 30sek. (weil 2 imputse pro umdrehung)

   End If

End If


'Ausgabe über UART##############################################################
If Zeit = 20 Then

   Zeit = 0

   Pwm01_str = Pwm01 / 2.55
   Pwm02_str = Pwm02 / 2.55

   Print "98765"                                            'Prüfnummer

   Waitms 50

   Print Rpm1_str

   Waitms 50

   Print Rpm2_str

   Waitms 50

   Print Pwm01_str

   Waitms 50

   Print Pwm02_str

   Waitms 50

   Print Temp1_str

   Waitms 50

   Print Temp2_str

End If

Loop


'isr von timer0#################################################################
Isr_timer0:                                                 'aller 1/30.5175 Sekunden

   Soft_timer = Soft_timer + 1

   If Soft_timer = 30 Then

      Rpm1 = Rpm1_temp
      Rpm2 = Rpm2_temp

      Rpm1_temp = 0
      Rpm2_temp = 0

      Soft_timer = 0
      X = 1

   End If

Return


'isr von int0###################################################################
Isr_int0:

   Rpm1_temp = Rpm1_temp + 1

Return


'isr von int1###################################################################
Isr_int1:

   Rpm2_temp = Rpm2_temp + 1

Return

End

[Klaus D. (kolisson)]

Hi Du,
ohne jetzt wirklich den ganzen Code durchdacht zu haben fällt mir auf,
dass die Ausdrucksform
'Ausgabe über 
UART##############################################################
If Zeit = 20 Then

sowieso zu einem Problem führen wird, weil es ja nur ausgefürt wird wenn 
exact 20 bestehen. Sollte dein programm also irgendwie länger brauchen 
ist vielleicht schon 21 erreicht und du wartest bis zum nächsten 
Overflow der Var.

versuch mal:
'Ausgabe über 
UART##############################################################
If Zeit >= 20 Then

Gruss Klaus

[Steffen W. (derwarze)]

Habe nur mal kurz durchgescrollt.
Mir fällt auf das bei 'Lüfterreglen' 2x 5 Sekunden gewartet wird, sehr 
ungünstig da dann die Programmschleife nur 1x in 10Sek durchlaufen wird.
Weiter ungünstig sind die Berechnungen mit Singlevariablen, ist bei 
Bascom grottenlahm, speicherintensiv und in fast allen Fällen, so auch 
hier, unnötig.
Bei der UART-Ausgabe sind auch wieder völlig unnötige Waitbefehle und 
auch wieder 2 Kommarechnungen. Da das aber Wordvariablen in der Rechnung 
sind geht das in die Hose.

Bisher habe ich es immer geschaft Gleitkommarechnungen zu vermeiden. Für 
die Datenanzeige lässt sich das Komma gut nachträglich einfügen wenn man 
den Umweg über Stringvariablen nimmt, ist auf jeden Fall weniger ZEit 
und Speicherintensiv.

[Klaus D. (kolisson)]

Steffen Warzecha schrieb:
> Bisher habe ich es immer geschaft Gleitkommarechnungen zu vermeiden. Für
> die Datenanzeige lässt sich das Komma gut nachträglich einfügen wenn man
> den Umweg über Stringvariablen nimmt, ist auf jeden Fall weniger ZEit
> und Speicherintensiv.

Da hast du meines Erachtens nach auch einen der Nägel auf den Kopf 
getroffen.
Als ich vor Jahren mal mit uC anfing habe ich auch "single" geschworen.
Als dann die Unzulänglickeiten hervortraten ging ich auf "Double" was 
wieder neue Probleme erzeugte.

Im Finale schaffe ich nun alles mit Integer (oder long) Arithmetik.
Leider ist das Gehirn so aufgebaut dass man gerne Kommastellen sehen 
möchte um dem Ergebnis mehr zu trauen.

wenn man es jedoch mit dem taschenrechner mal rückwärts rechnet erkenn 
man dann sehr leicht warum die Ergebnisse nicht den erwartungen 
entsprechen.

Ich erinnere mich gerne an den Hype mit den Apfelmännchen, der in den 
1980gern gab. Da waren komplizierte Formeln in der CT mit Realteil und 
Imaginäranteil drinne. Jeder hat das dann programmiert und tatsächlich 
kam ein solches Apfelmännlein heraus. Als ich das alte pascal-Programm 
vor ein paar Jahren mal wieder herausgekramt hatte und die Formel 
einfach duch
die Formel :
 dim differenz as whatever
x=10
do
y=x / 3
z = y * 3
differenz = z-x
loop until differenz has overflow

.. und siehe da, es ist das gleiche Apfelmännchen.
Vielleicht nicht so bunt aber es geht schon.

das Apfelmännchen ist also keine geheime Information sondern eher der 
Bereich der möglichen Rundungsfehler den man vermeiden sollte.

Gruss Klaus

[Peter K. (pker)]

Klaus De lisson schrieb:
> versuch mal:
> 'Ausgabe über
> UART##############################################################
> If Zeit >= 20 Then

das hat geholfen DANKE

Hab da noch ne andere Frage.
Und zwar übertrage ich ja Daten über den Serialport vom AVR zum PC.
Drehzahlen Temperaturen und PWM-stufe siehe Bild.
PWM-Stufe in ProgressBar 1 und 2 (die oberen 2)
der Rest ist eigentlich zu erkennen auf dem Bild.
Um die Reinfolge der Daten zu gewährleisten musste ich wie folgt 
vorgehen.

Bascom Code:

 Print "98765"

   Waitms 50

   Print Rpm1_str

   Waitms 50

   Print Rpm2_str

   Waitms 50

   Print Pwm01

   Waitms 50

   Print Pwm02

   Waitms 50

   Print Temp1_str

   Waitms 50

   Print Temp2_str

VB2010 Code:

Private Sub SerialPort1_DataReceived(ByVal sender As Object, ByVal e As System.IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived
        Try
            comein = SerialPort1.ReadLine
            Me.Invoke(New EventHandler(AddressOf auswertung))
        Catch ex As Exception

        End Try

    End Sub

    Private Sub auswertung()
        If a = 0 Then

            If comein = "98765" Then                 'Prüfnummer 98765
                a = 1
            Else
                a = 0
            End If

        ElseIf a = 1 Then
            a = 2

            Label1.Text = "FAN CPU:  " & comein & " RPM"

        ElseIf a = 2 Then
            a = 3

            Label2.Text = "FAN Umgebung:  " & comein & " RPM"

        ElseIf a = 3 Then
            a = 4

            If comein > 100 Then
                comein = 100
            ElseIf comein < 0 Then
                comein = 0
            End If

            ProgressBar1.Value = comein
            Label5.Text = "PWM " & comein

        ElseIf a = 4 Then
            a = 5

            If comein > 100 Then
                comein = 100
            ElseIf comein < 0 Then
                comein = 0
            End If

            ProgressBar2.Value = comein
            Label6.Text = "PWM " & comein


        ElseIf a = 5 Then
            a = 6

            Label7.Text = comein
            comein = comein / 10
            Label3.Text = "Temperatur CPU:  " & comein & "°C"

            If comein >= 100 Then
                comein = 100
            ElseIf comein <= 0 Then
                comein = 0
            End If

            ProgressBar3.Value = comein

        ElseIf a = 6 Then
            a = 0

            Label8.Text = comein
            comein = comein / 10
            Label4.Text = "Temperatur Umgebung:  " & comein & "°C"

            If comein >= 100 Then
                comein = 100
            ElseIf comein <= 0 Then
                comein = 0
            End If

            ProgressBar4.Value = comein

        End If

    End Sub

Jetzt haut das aber nicht hin so wie ich es will.
Ich bekomme manchmal komische Werte angezeigt und manchmal auch die 
Prüfnummer in der Temperatur angezeigt.

Wo liegt mein Problem hier oder wie kann man das anders machen??

[Klaus D. (kolisson)]

hallo Autor: Peter K. (pker) ,

ich hab wirklich nicht die Lust deinen VB Code zu lesen und diesen noch 
verstehen zu wollen. Allerdings erinnere ich mich dass ich diese Dinge 
auch schon mal gemacht habe (allerdings verwende ich Vbasic 2006 ohne 
den .net Syntax)

selbst bei Vb6 ist es so, dass sich Probleme bei der sychronisation 
einstellen wenn man viele Print-Befehle hintereinander absetzt zumal 
eben VB und Windows nicht gerade ein Echtzeit-system ist.
wenn du jedoch im AVR zunächst eine String mit bekannter Länge bildest 
wird es besser.
z.B.

Dim sendstring as String * 200
*****  hier hast du also einen String mit 200 zeichen
Print sendstring
******  sendet 200 Zeichen am Stück
dim rpm1string as string * 5 (für word variablen oder *3 für byte)
rpm1string = str(rpm1wert)


nun müssen wir überlegen was wir senden.
Da könnte man z.B. sagen das der Präfix eines Eintrages immer 4 zeichen 
lang ist (also immer die gleiche Länge)

sendstring="Rpm1"+ rpm1string+ "Rpm2"+rpm2str"

dann bekommst du auf dem PC eine einzige Sendung mit dem kompletten 
Telegramm

Nun wollen wir das Telegramm auch wieder zerlegen und fügen ein 
Trennzeichen ein. Dies könnte z.B. ein Semikolon sein
Der Sendstring wäre dann:

sendstring="Rpm1"+ rpm1string+ ";" +"Rpm2"+rpm2str"
abgeschlossen wird der String mit VBLF und VBCR

nun kannst du im VB (und da hast du viel mehr rechenleistung) den String 
wieder zerpflücken.
Du triigerst den VB Empfang mit dem VBLF und VBCR und prüfst die länge 
des String. Stimmt die Länge nicht hast du Fehlerhaften Empfang gehabt.
Simmt die Länge kannstt du in VB mit instring das Ganze wieder zerlegen.

Ich hoffe du verstehst das soweit.

Gruss Klaus

p.s.
wenn dein uC keinen Quarz verwendet sondern den internen RC wird es noch 
schwieriger zu synchen.

[Peter K. (pker)]

Klaus De lisson schrieb:
> Ich hoffe du verstehst das soweit.

Das Prinzip leuchtet mir ein!

Nur an der Umsetzung habert es noch.


Ich habe jetzt 6 werte in Strings umgewandelt mit "string=str(wert)".
Die Strings haben alle 5 Stellen (string * 5).
Habe alle Strings zusammen gefügt mit 
"ausgabe_string=string1+string2..." und in einen Ausgabe String 
geschrieben (dieser hat 50 Stellen (ausgabe_string * 50)).
Jetzt gebe ich mit "Print ausgabe_string" die Werte aus.

Laut deiner Aussage müssten jetzt 50 Zeichen Übertragen werden.
die ersten 30 mit meinen werten.

Soweit Korrekt?

Ich nehme mal an das nicht genutzte Zeichen in einem Terminal nicht 
angezeigt werden aber trotzdem übertragen werden.
Dann Würde soweit auch alles hin hauen.



Klaus De lisson schrieb:
> nun kannst du im VB (und da hast du viel mehr rechenleistung) den String
> wieder zerpflücken.
> Du triigerst den VB Empfang mit dem VBLF und VBCR und prüfst die länge
> des String. Stimmt die Länge nicht hast du Fehlerhaften Empfang gehabt.

Da bin ich etwas unerfahren und habe keine Ahnung wie ich das machen 
soll.

> Simmt die Länge kannstt du in VB mit instring das Ganze wieder zerlegen.

Da Bräuchte ich auch etwas Hilfe.

[Klaus D. (kolisson)]

Peter K. schrieb:
> Laut deiner Aussage müssten jetzt 50 Zeichen Übertragen werden.
> die ersten 30 mit meinen werten.
>
> Soweit Korrekt?

Nein!
(ausgabe_string * 50) bedeutet ja nur das dein "Ausgabeeimer" das 
Fassungsvermögen von 50 hat. wenn du aber nur 30 in dem Eimer füllst 
kommen auch nur 30 heraus. Zusätzlich aber durch den Printbefehl noch 
<CR> und ein <LF> angehängt. (siehe chr(10) und chr (13))

Beim Enpfang musst du halt in VB proggen das ein CR und/oder ein LF das 
Ende einer Übertragung ist. Dann musst du den Empfangsstring bereinigen 
indem du am Ende 1 oder 2 Zeichen abschneiden um die CR und LF sofern 
vorhanden zu entfernen.

String = left(string, len(string-2))  z.b.

dann schneidest du den rest wieder in Stücke so dass deine 
Ursprungsstrings wieder entstehen.

z.B
string1 = mid(empfangsstring,1,5)
string2 = mid(empfangsstring,6,5)
u.s.w.

bitte nagel mich nicht auf die Syntax fest da ich ja sowieso ne andere 
VB Version habe.

Ich schätze aber, das du mit dem Begriffen sehr gut goolen kannst.

Gruss Klaus

ps.:
lad dir mal HTERM runter und schau dir dann an was du empfängst bevor du 
in VB anfängst zu proggen