ADC dsPICCK256MP508

K. OP #7313151
Lesenswert?
• ▲
▼

Hey Leute,

ich sitze aktuell an meinem Praxisprojekt in der UNI. Dort baue ich ein DC/DC Wandler der mit einem uC gesteuert werden soll. Die Uni hat den dsPIC33CK256MP508 besorgt, sodass ich grad dran sitze. Die Software ist größtenteils schon geschrieben in Visual Studio. MIT PLECS auch der Algorithmus schon getestet um die PEAKS der Ausgangsspannung zu berechnen.

Dank meiner Uni durfte ich mir ein Funktionsgenerator mit nach Hause nehmen, sodass ich schrittweise alles in den uC implementieren und testen kann.

Ich habe mit dem ADC angefangen. Benutze den Code Generator von MpLab.

Soweit funktioniert auch das einlesen der Spannung. Wenn es eine DC Spannung ist zeigt der mir auch immer den Wert ohne groß abzuweichen.

Beim AC Sinus mit 50 HZ klappt das einlesen auch. Allerdings springt er gerne. Ich vermute es liegt am Rauschen. Die Kenndaten der ADC Einstellung: Conversation Clock Source : FOSC Conversation Time : 9.25 uS Traget Share Core Sampling Time : 0.25 ms

Meint ihr die Sprünge aus dem Bild sind nomral?

Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
K. OP #7313177
Lesenswert?
• ▲
▼

Hey

Der Schaltplan sieht so aus dass ich ein Spannungsteiler habe mehr nicht und am Wiederstand die Spannung zum AN Pin und GND führe. Der Funktionsgenerator ist auf 50 Hz Sinus mit offset eingestellt. Zwei Wiederstände mit 380 Ohm Sinus Ueff = 2.4 V DC OFFSet = 5.3 V AM Spannungsteiler wird: Ueff = 677 mV abgegriffen mit offset =1.48 V

BIm Bild ist schaltplan hinzugefügt Die Bilder zum Programm sind doch hinzugefügt. Mehr Code habe ich aktuell nicht..... Leider habe ich kein oszi, hatte den Funktionsgenerator in der Uni unterm oszi angeschaut. Da ist ein 50 HZ Sinus Code:

1
 
#include "mcc_generated_files/system.h"

2
 
#include "mcc_generated_files/mcc.h"

3
 


4
 
/*

5
 
                         Main application

6
 
 */

7
 
volatile int ADCValue = 0; //

8
 
float Voltage = 0;

9
 


10
 
void MY_ISR(void)

11
 
{

12
 
    //ADC1_SoftwareTriggerDisable(); // Conversation stoppen

13
 
    ADCValue = ADC1_ConversionResultGet(Uout);

14
 
    Voltage = ADCValue * (3.3/4095);

15
 
    printf("\n\r ADC Value: %d\n\r",ADCValue);

16
 
    printf("\n\r ADC Voltage: %f\n\r",Voltage);

17
 
  

18
 
    ADC1_SoftwareTriggerEnable();

19
 
    

20
 
}

21
 
int main(void)

22
 
{

23
 
    // initialize the device

24
 
    SYSTEM_Initialize();

25
 
    ADC1_Enable();

26
 
    ADC1_ChannelSelect(Uout); // Channel auswählen

27
 
    ADC1_SetUoutInterruptHandler(MY_ISR); // Eigenen Interuppt definieren

28
 
    ADC1_SoftwareTriggerEnable();  //Erste Messung starten

29
 
    

30
 
    

31
 
    while (1)

32
 
    {

33
 
       

34
 
    }

35
 
    return 1; 

36
 
}

37
 
/**

38
 
 End of File

39
 
*/
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7313214
Lesenswert?
• ▲
▼

So wie ich das verstanden habe setzt es die Sample Time. Daher habe ich da 4 kHz eingetragen.

Schaue mir jetzt mal die Register an, ich ging davon aus, dass er das selbst machst. Überprüfe das mal

Bei nur Offset wird mir der richtige Wert wie auf meinem FLuke 28 II Multimeter angezeigt.

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7313246
Lesenswert?
• ▲
▼

Mir fällt auf, dass er diese massiven Sprünge wie von ADC Value 480 auf 1802 selten macht. Bin noch beim überprüfen der Register sieht soweit gut aus.

Bin mir beim Register ADCON3 unsicher ob beim CNVCHSEL nicht der An ausgewählt werdne muss, den ich benutze. Grad ist er auf AN0 gesetzt ich nutze An22 Die Erklärung: CNVCHSEL [5:0]: Channel Number Selection for Software Individual Channel Conversion Trigger bits These bits define a channel to be converted when the CNVRTCH bit is set

Die Clock seeting benutzte ich Divider 1 das heißt die Clock läuft mit 4MHZ

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7313277
Lesenswert?
• ▲
▼

Die Register passen soweit. Hab einzig mal Oversampling von 4 auf 16 gesetellt.

Dann gehe ich mal davon aus, dass es am rauschen des Frequenzgenerator liegt, denn bei DC passt alles.

Hab auch kein RC Filter und Kondensator zur Messung, dass Spielt bestimmt auch eine Rolle, sofern im Code keine Fehler vorhanden sind.

Wie ich sehe springt er von der MAX Amplitude direkt auf den Min Wert, steigt dann wieder auf den MAX Wert und springt dann auf Min Wert. Eventuell hilft diese Fehlerbeschreibung

Antwort Zitieren Bearbeiten Löschen Beitrag melden
uwe Gast #7313767
Lesenswert?
• ▲
▼

Dann leg doch mal auf AN22 einen definierten Pegel und falls dieser nicht gemessen wird dann leg diesen definierten Pegel auf AN0. Sollte mit dem Funktionsgenerator möglich sein auch eine Gleichspannung zu erzeugen... im schlimmsten Fall nimm ein Rechteck mit 0,1Hz.

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7313777
Lesenswert?
• ▲
▼

Ich esse kurz auf und dann schicke ich die Init Funktion. Dort ist im Code des Register eingestellt.

5 Minuten

Den der Code Generator definiert Funktion für einen in der Header, die man selbst nutzen kann. Die Registrr Einstellungen werden einmal in der Init Funktion durchgeführt und in diesen Funktion selber. Ich muss da nichts mehr mit Bits setzen machen.

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7313792
Lesenswert?
• ▲
▼

Hier die Init des Adc

1
 
void ADC1_Initialize (void)

2
 
{

3
 
    // ADSIDL disabled; ADON enabled; 

4
 
    ADCON1L = (0x8000 & 0x7FFF); //Disabling ADON bit

5
 
    // FORM Integer; SHRRES 12-bit resolution; 

6
 
    ADCON1H = 0x60;

7
 
    // PTGEN disabled; SHRADCS 2; REFCIE disabled; SHREISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; REFERCIE disabled; EIEN disabled; 

8
 
    ADCON2L = 0x00;

9
 
    // SHRSAMC 318; 

10
 
    ADCON2H = 0x13E;

11
 
    // SWCTRG disabled; SHRSAMP disabled; SUSPEND disabled; SWLCTRG disabled; SUSPCIE disabled; CNVCHSEL AN0; REFSEL disabled; 

12
 
    ADCON3L = 0x00;

13
 
    // SHREN enabled; C1EN disabled; C0EN disabled; CLKDIV 1; CLKSEL FOSC; 

14
 
    ADCON3H = (0x4080 & 0xFF00); //Disabling C0EN, C1EN, C2EN, C3EN and SHREN bits

15
 
    // SAMC0EN disabled; SAMC1EN disabled; 

16
 
    ADCON4L = 0x00;

17
 
    // C0CHS AN0; C1CHS AN1; 

18
 
    ADCON4H = 0x00;

19
 
    // SIGN0 disabled; SIGN4 disabled; SIGN3 disabled; SIGN2 disabled; SIGN1 disabled; SIGN7 disabled; SIGN6 disabled; DIFF0 disabled; SIGN5 disabled; DIFF1 disabled; DIFF2 disabled; DIFF3 disabled; DIFF4 disabled; DIFF5 disabled; DIFF6 disabled; DIFF7 disabled; 

20
 
    ADMOD0L = 0x00;

21
 
    // DIFF15 disabled; DIFF14 disabled; SIGN8 disabled; DIFF13 disabled; SIGN14 disabled; DIFF12 disabled; SIGN15 disabled; DIFF11 disabled; DIFF10 disabled; SIGN9 disabled; DIFF8 disabled; DIFF9 disabled; SIGN10 disabled; SIGN11 disabled; SIGN12 disabled; SIGN13 disabled; 

22
 
    ADMOD0H = 0x00;

23
 
    // DIFF19 disabled; DIFF18 disabled; DIFF17 disabled; DIFF16 disabled; DIFF23 disabled; SIGN16 disabled; DIFF22 disabled; SIGN17 disabled; DIFF21 disabled; SIGN18 disabled; DIFF20 disabled; SIGN19 disabled; SIGN20 disabled; SIGN21 disabled; SIGN22 disabled; SIGN23 disabled; 

24
 
    ADMOD1L = 0x00;

25
 
    // SIGN24 disabled; DIFF25 disabled; DIFF24 disabled; SIGN25 disabled; 

26
 
    ADMOD1H = 0x00;

27
 
    // IE15 disabled; IE1 disabled; IE0 disabled; IE3 disabled; IE2 disabled; IE5 disabled; IE4 disabled; IE10 disabled; IE7 disabled; IE6 disabled; IE9 disabled; IE13 disabled; IE8 disabled; IE14 disabled; IE11 disabled; IE12 disabled; 

28
 
    ADIEL = 0x00;

29
 
    // IE17 disabled; IE18 disabled; IE16 disabled; IE19 disabled; IE20 disabled; IE21 disabled; IE24 enabled; IE25 enabled; IE22 enabled; IE23 disabled; 

30
 
    ADIEH = 0x340;

31
 
    // CMPEN10 disabled; CMPEN11 disabled; CMPEN6 disabled; CMPEN5 disabled; CMPEN4 disabled; CMPEN3 disabled; CMPEN2 disabled; CMPEN1 disabled; CMPEN0 disabled; CMPEN14 disabled; CMPEN9 disabled; CMPEN15 disabled; CMPEN8 disabled; CMPEN12 disabled; CMPEN7 disabled; CMPEN13 disabled; 

32
 
    ADCMP0ENL = 0x00;

33
 
    // CMPEN10 disabled; CMPEN11 disabled; CMPEN6 disabled; CMPEN5 disabled; CMPEN4 disabled; CMPEN3 disabled; CMPEN2 disabled; CMPEN1 disabled; CMPEN0 disabled; CMPEN14 disabled; CMPEN9 disabled; CMPEN15 disabled; CMPEN8 disabled; CMPEN12 disabled; CMPEN7 disabled; CMPEN13 disabled; 

34
 
    ADCMP1ENL = 0x00;

35
 
    // CMPEN10 disabled; CMPEN11 disabled; CMPEN6 disabled; CMPEN5 disabled; CMPEN4 disabled; CMPEN3 disabled; CMPEN2 disabled; CMPEN1 disabled; CMPEN0 disabled; CMPEN14 disabled; CMPEN9 disabled; CMPEN15 disabled; CMPEN8 disabled; CMPEN12 disabled; CMPEN7 disabled; CMPEN13 disabled; 

36
 
    ADCMP2ENL = 0x00;

37
 
    // CMPEN10 disabled; CMPEN11 disabled; CMPEN6 disabled; CMPEN5 disabled; CMPEN4 disabled; CMPEN3 disabled; CMPEN2 disabled; CMPEN1 disabled; CMPEN0 disabled; CMPEN14 disabled; CMPEN9 disabled; CMPEN15 disabled; CMPEN8 disabled; CMPEN12 disabled; CMPEN7 disabled; CMPEN13 disabled; 

38
 
    ADCMP3ENL = 0x00;

39
 
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 

40
 
    ADCMP0ENH = 0x00;

41
 
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 

42
 
    ADCMP1ENH = 0x00;

43
 
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 

44
 
    ADCMP2ENH = 0x00;

45
 
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 

46
 
    ADCMP3ENH = 0x00;

47
 
    // CMPLO 0; 

48
 
    ADCMP0LO = 0x00;

49
 
    // CMPLO 0; 

50
 
    ADCMP1LO = 0x00;

51
 
    // CMPLO 0; 

52
 
    ADCMP2LO = 0x00;

53
 
    // CMPLO 0; 

54
 
    ADCMP3LO = 0x00;

55
 
    // CMPHI 3; 

56
 
    ADCMP0HI = 0x03;

57
 
    // CMPHI 0; 

58
 
    ADCMP1HI = 0x00;

59
 
    // CMPHI 0; 

60
 
    ADCMP2HI = 0x00;

61
 
    // CMPHI 0; 

62
 
    ADCMP3HI = 0x00;

63
 
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 

64
 
    ADFL0CON = 0x400;

65
 
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 

66
 
    ADFL1CON = 0x400;

67
 
    // OVRSAM 16x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 

68
 
    ADFL2CON = 0xC00;

69
 
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN22; IE disabled; FLEN enabled; 

70
 
    ADFL3CON = 0x8416;

71
 
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 

72
 
    ADCMP0CON = 0x00;

73
 
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 

74
 
    ADCMP1CON = 0x00;

75
 
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 

76
 
    ADCMP2CON = 0x00;

77
 
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 

78
 
    ADCMP3CON = 0x00;

79
 
    // LVLEN9 disabled; LVLEN8 disabled; LVLEN11 disabled; LVLEN7 disabled; LVLEN10 disabled; LVLEN6 disabled; LVLEN13 disabled; LVLEN5 disabled; LVLEN12 disabled; LVLEN4 disabled; LVLEN15 disabled; LVLEN3 disabled; LVLEN14 disabled; LVLEN2 disabled; LVLEN1 disabled; LVLEN0 disabled; 

80
 
    ADLVLTRGL = 0x00;

81
 
    // LVLEN20 disabled; LVLEN22 disabled; LVLEN21 disabled; LVLEN24 disabled; LVLEN23 disabled; LVLEN25 disabled; LVLEN17 disabled; LVLEN16 disabled; LVLEN19 disabled; LVLEN18 disabled; 

82
 
    ADLVLTRGH = 0x00;

83
 
    // SAMC 0; 

84
 
    ADCORE0L = 0x00;

85
 
    // SAMC 0; 

86
 
    ADCORE1L = 0x00;

87
 
    // RES 12-bit resolution; EISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; ADCS 2; 

88
 
    ADCORE0H = 0x300;

89
 
    // RES 12-bit resolution; EISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; ADCS 2; 

90
 
    ADCORE1H = 0x300;

91
 
    // EIEN9 disabled; EIEN7 disabled; EIEN8 disabled; EIEN5 disabled; EIEN6 disabled; EIEN3 disabled; EIEN4 disabled; EIEN1 disabled; EIEN2 disabled; EIEN13 disabled; EIEN0 disabled; EIEN12 disabled; EIEN11 disabled; EIEN10 disabled; EIEN15 disabled; EIEN14 disabled; 

92
 
    ADEIEL = 0x00;

93
 
    // EIEN17 disabled; EIEN16 disabled; EIEN25 disabled; EIEN19 disabled; EIEN18 disabled; EIEN20 disabled; EIEN24 disabled; EIEN23 disabled; EIEN22 disabled; EIEN21 disabled; 

94
 
    ADEIEH = 0x00;

95
 
    // C0CIE disabled; C1CIE disabled; SHRCIE disabled; WARMTIME 32768 Source Clock Periods; 

96
 
    ADCON5H = (0xF00 & 0xF0FF); //Disabling WARMTIME bit

97
 
  

98
 
    //Assign Default Callbacks

99
 
    ADC1_SetCommonInterruptHandler(&ADC1_CallBack);

100
 
    ADC1_SetUoutInterruptHandler(&ADC1_Uout_CallBack);

101
 
    ADC1_Setchannel_AN24InterruptHandler(&ADC1_channel_AN24_CallBack);

102
 
    ADC1_Setchannel_AN25InterruptHandler(&ADC1_channel_AN25_CallBack);

103
 
    

104
 
    // Clearing Uout interrupt flag.

105
 
    IFS7bits.ADCAN22IF = 0;

106
 
    // Enabling Uout interrupt.

107
 
    IEC7bits.ADCAN22IE = 1;

108
 
    // Clearing channel_AN24 interrupt flag.

109
 
    IFS12bits.ADCAN24IF = 0;

110
 
    // Enabling channel_AN24 interrupt.

111
 
    IEC12bits.ADCAN24IE = 1;

112
 
    // Clearing channel_AN25 interrupt flag.

113
 
    IFS12bits.ADCAN25IF = 0;

114
 
    // Enabling channel_AN25 interrupt.

115
 
    IEC12bits.ADCAN25IE = 1;

116
 


117
 
    // Setting WARMTIME bit

118
 
    ADCON5Hbits.WARMTIME = 0xF;

119
 
    // Enabling ADC Module

120
 
    ADCON1Lbits.ADON = 0x1;

121
 
    // Enabling Power for the Shared Core

122
 
    ADC1_SharedCorePowerEnable();

123
 


124
 
    //TRGSRC0 Common Software Trigger; TRGSRC1 None; 

125
 
    ADTRIG0L = 0x01;

126
 
    //TRGSRC3 None; TRGSRC2 None; 

127
 
    ADTRIG0H = 0x00;

128
 
    //TRGSRC4 None; TRGSRC5 None; 

129
 
    ADTRIG1L = 0x00;

130
 
    //TRGSRC6 None; TRGSRC7 None; 

131
 
    ADTRIG1H = 0x00;

132
 
    //TRGSRC8 None; TRGSRC9 None; 

133
 
    ADTRIG2L = 0x00;

134
 
    //TRGSRC11 None; TRGSRC10 None; 

135
 
    ADTRIG2H = 0x00;

136
 
    //TRGSRC13 None; TRGSRC12 None; 

137
 
    ADTRIG3L = 0x00;

138
 
    //TRGSRC15 None; TRGSRC14 None; 

139
 
    ADTRIG3H = 0x00;

140
 
    //TRGSRC17 None; TRGSRC16 None; 

141
 
    ADTRIG4L = 0x00;

142
 
    //TRGSRC19 None; TRGSRC18 None; 

143
 
    ADTRIG4H = 0x00;

144
 
    //TRGSRC20 None; TRGSRC21 None; 

145
 
    ADTRIG5L = 0x00;

146
 
    //TRGSRC22 Common Software Trigger; TRGSRC23 None; 

147
 
    ADTRIG5H = 0x01;

148
 
    //TRGSRC24 Common Software Trigger; TRGSRC25 Common Software Trigger; 

149
 
    ADTRIG6L = 0x101;

150
 
}

Hier die Funktion für den ADC

1
 
void ADC1_Core0PowerEnable ( ) 

2
 
{

3
 
    ADCON5Lbits.C0PWR = 1; 

4
 
    while(ADCON5Lbits.C0RDY == 0);

5
 
    ADCON3Hbits.C0EN = 1;     

6
 
}

7
 


8
 
void ADC1_Core1PowerEnable ( ) 

9
 
{

10
 
    ADCON5Lbits.C1PWR = 1; 

11
 
    while(ADCON5Lbits.C1RDY == 0);

12
 
    ADCON3Hbits.C1EN = 1;     

13
 
}

14
 


15
 
void ADC1_SharedCorePowerEnable ( ) 

16
 
{

17
 
    ADCON5Lbits.SHRPWR = 1;   

18
 
    while(ADCON5Lbits.SHRRDY == 0);

19
 
    ADCON3Hbits.SHREN = 1;   

20
 
}

21
 


22
 


23
 
void __attribute__ ((weak)) ADC1_CallBack ( void )

24
 
{ 

25
 


26
 
}

27
 


28
 
void ADC1_SetCommonInterruptHandler(void* handler)

29
 
{

30
 
    ADC1_CommonDefaultInterruptHandler = handler;

31
 
}

32
 


33
 
void __attribute__ ((weak)) ADC1_Tasks ( void )

34
 
{

35
 
    if(IFS5bits.ADCIF)

36
 
    {

37
 
        if(ADC1_CommonDefaultInterruptHandler) 

38
 
        { 

39
 
            ADC1_CommonDefaultInterruptHandler(); 

40
 
        }

41
 


42
 
        // clear the ADC1 interrupt flag

43
 
        IFS5bits.ADCIF = 0;

44
 
    }

45
 
}

46
 


47
 
void __attribute__ ((weak)) ADC1_Uout_CallBack( uint16_t adcVal )

48
 
{ 

49
 


50
 
}

51
 


52
 
void ADC1_SetUoutInterruptHandler(void* handler)

53
 
{

54
 
    ADC1_UoutDefaultInterruptHandler = handler;

55
 
}

56
 


57
 
void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN22Interrupt ( void )

58
 
{

59
 
    uint16_t valUout;

60
 
    //Read the ADC value from the ADCBUF

61
 
    valUout = ADCBUF22;

62
 


63
 
    if(ADC1_UoutDefaultInterruptHandler) 

64
 
    { 

65
 
        ADC1_UoutDefaultInterruptHandler(valUout); 

66
 
    }

67
 


68
 
    //clear the Uout interrupt flag

69
 
    IFS7bits.ADCAN22IF = 0;

70
 
}

71
 


72
 
void __attribute__ ((weak)) ADC1_channel_AN24_CallBack( uint16_t adcVal )

73
 
{ 

74
 


75
 
}

76
 


77
 
void ADC1_Setchannel_AN24InterruptHandler(void* handler)

78
 
{

79
 
    ADC1_channel_AN24DefaultInterruptHandler = handler;

80
 
}

81
 


82
 
void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN24Interrupt ( void )

83
 
{

84
 
    uint16_t valchannel_AN24;

85
 
    //Read the ADC value from the ADCBUF

86
 
    valchannel_AN24 = ADCBUF24;

87
 


88
 
    if(ADC1_channel_AN24DefaultInterruptHandler) 

89
 
    { 

90
 
        ADC1_channel_AN24DefaultInterruptHandler(valchannel_AN24); 

91
 
    }

92
 


93
 
    //clear the channel_AN24 interrupt flag

94
 
    IFS12bits.ADCAN24IF = 0;

95
 
}

96
 


97
 
void __attribute__ ((weak)) ADC1_channel_AN25_CallBack( uint16_t adcVal )

98
 
{ 

99
 


100
 
}

101
 


102
 
void ADC1_Setchannel_AN25InterruptHandler(void* handler)

103
 
{

104
 
    ADC1_channel_AN25DefaultInterruptHandler = handler;

105
 
}

106
 


107
 
void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN25Interrupt ( void )

108
 
{

109
 
    uint16_t valchannel_AN25;

110
 
    //Read the ADC value from the ADCBUF

111
 
    valchannel_AN25 = ADCBUF25;

112
 


113
 
    if(ADC1_channel_AN25DefaultInterruptHandler) 

114
 
    { 

115
 
        ADC1_channel_AN25DefaultInterruptHandler(valchannel_AN25); 

116
 
    }

117
 


118
 
    //clear the channel_AN25 interrupt flag

119
 
    IFS12bits.ADCAN25IF = 0;

120
 
}

Als Multimeter habe ich den Fluke 28 II Also die Messungen damit sind ziemlich genau. Kann auch Frequenz messen. Das ist mein eigenes, die Uni kann sich das leider nicht leisten, und hatte mir so ein uralt gerät mit gegeben. Da ich zum Geb die Fluke bekommen hatte, nutze ich diesen. Der Funktionsgenerator ist auch Uralt

Im Anhang ist mein eigenes Development Bord abgebildet es enthält den selben Chip wie in der Uni verwerndet

Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7314338
Lesenswert?
• ▲
▼

Teo D. schrieb:

Kürsat schrieb:

Meint ihr die Sprünge aus dem Bild sind nomral?

Solange ein Steckbrett involviert ist, ja. Sowas taugt gern auch als Seismometer.... ;)

Hab jetzt mal den Funktionsgenerator nach dem ich Ihn mit dem Multimeter richtig eingestellt habe direkt an den ADC angeschlossen.

Er springt immer noch, meiner Meinung weniger, aber immer noch von Max 2.25V ( das exakt was Multimeter anzeigt) auf 0.90 V, was ich etwas für viel halte. Insbesondere das eine Messung 84,625 us dauert. Hier stellt sich die Frage ob das Oversampling es verlängert, selbst dann dürfte der Sprung nicht so groß sein.

Und bei DC zeigt er den exakten Wert an.

Seltsam.

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7314351
Lesenswert?
• ▲
▼

uwe schrieb:

Dann leg doch mal auf AN22 einen definierten Pegel und falls dieser nicht gemessen wird dann leg diesen definierten Pegel auf AN0. Sollte mit dem Funktionsgenerator möglich sein auch eine Gleichspannung zu erzeugen... im schlimmsten Fall nimm ein Rechteck mit 0,1Hz.

Also hab den DC angeschlossen bei AN0 er zeigt mir exakten Wert vom Multimeter an und auch den selben von AN0

Beim Sinus springt er leider auch

Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas Z. #7314399
Lesenswert?
• ▲
▼

Wie lange braucht printf um die Werte auszugeben. Ist die Zeit > als die ADC repeat time gehen Werte verloren.

Schreib einfach mal den Speicher mit deinen ADC Werten voll und gib die Daten danach aus. Du kannst auch mal einen Pin vor und hinter den printfs togglen und mit dem Oszi die Ausgabezeit Zeit messen.

Antwort Zitieren Bearbeiten Löschen Beitrag melden
K. OP #7314413
Lesenswert?
• ▲
▼

Thomas Z. schrieb:

Wie lange braucht printf um die Werte auszugeben. Ist die Zeit > als die ADC repeat time gehen Werte verloren.

Schreib einfach mal den Speicher mit deinen ADC Werten voll und gib die Daten danach aus. Du kannst auch mal einen Pin vor und hinter den printfs togglen und mit dem Oszi die Ausgabezeit Zeit messen.

dank dir da lag genau der Fehler!

Hab jetzt ein Ringbuffer geschrieben den ich Fülle und wieder auslese und siehe da die Sprünge sind weg.

Vielen Dank!

LG

Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren