ADC dsPICCK256MP508

[K. (yberion45)]

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?

[uwe (Gast)]

Wie soll dir denn bei der Datenlage jemand Helfen können?
Kannst du da irgendwo einen 50Hz Sinus sehen?
Wo ist das Programm?
Wie ist der Funktionsgenerator eingestellt?
Wie sieht der Schaltplan aus?

[K. (yberion45)]

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:

#include "mcc_generated_files/system.h"
#include "mcc_generated_files/mcc.h"

/*
                         Main application
 */
volatile int ADCValue = 0; //
float Voltage = 0;

void MY_ISR(void)
{
    //ADC1_SoftwareTriggerDisable(); // Conversation stoppen
    ADCValue = ADC1_ConversionResultGet(Uout);
    Voltage = ADCValue * (3.3/4095);
    printf("\n\r ADC Value: %d\n\r",ADCValue);
    printf("\n\r ADC Voltage: %f\n\r",Voltage);
  
    ADC1_SoftwareTriggerEnable();
    
}
int main(void)
{
    // initialize the device
    SYSTEM_Initialize();
    ADC1_Enable();
    ADC1_ChannelSelect(Uout); // Channel auswählen
    ADC1_SetUoutInterruptHandler(MY_ISR); // Eigenen Interuppt definieren
    ADC1_SoftwareTriggerEnable();  //Erste Messung starten
    
    
    while (1)
    {
       
    }
    return 1; 
}
/**
 End of File
*/

[uwe (Gast)]

Kürsat schrieb:
> Die Kenndaten der ADC Einstellung:
> Conversation Clock Source : FOSC
> Conversation Time : 9.25 uS
> Traget Share Core Sampling Time : 0.25 ms

Wo in deinem Programm stellst du das denn ein?

[K. (yberion45)]

Im Code Generator

Hänge die Bilder an vom Setup

und der Code Generator erstellt dann mit den Einstellungen ein fertigen 
Code, wo ich nur noch über Funktion den ADC steuern kann

[uwe (Gast)]

Alles beachtet was den ADC angeht?
https://ww1.microchip.com/downloads/en/DeviceDoc/70621c.pdf

Die Werte in den Registern stimmen für deine gewünschte Funktion?
Ab Seite 299:
https://ww1.microchip.com/downloads/en/DeviceDoc/dsPIC33CK256MP508-Family-Data-Sheet-DS70005349H.pdf

[uwe (Gast)]

Was macht denn die "Target share core sampling time" für einen Einfluss 
bzw. wofür ist die da?

[K. (yberion45)]

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.

[K. (yberion45)]

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

[K. (yberion45)]

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

[uwe (Gast)]

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.

[K. (yberion45)]

Hab ein DC mit 1 V angelegt am AN22, dort zeigt er exakt auch 1 V an, 
der letzte Bit schwankt manchmal um 1 Bit.

Reicht das als definierter Pegel oder soll ich noch ein Rechteck 
anlegen?

Lg

[uwe (Gast)]

Oder schick doch mal die Werte die in den GANZEN Konfigurationsregistern 
des ADCs eingestellt sind, sonst ist das alles nicht nachzuvollziehen 
bzw. Zeig den Code wo die Werte eingetragen werden. Oder benutze die 
Beispielprogramme aus diesem Dokument:
https://ww1.microchip.com/downloads/en/DeviceDoc/70621c.pdf

[K. (yberion45)]

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.

[K. (yberion45)]

Hier die Init des Adc

void ADC1_Initialize (void)
{
    // ADSIDL disabled; ADON enabled; 
    ADCON1L = (0x8000 & 0x7FFF); //Disabling ADON bit
    // FORM Integer; SHRRES 12-bit resolution; 
    ADCON1H = 0x60;
    // PTGEN disabled; SHRADCS 2; REFCIE disabled; SHREISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; REFERCIE disabled; EIEN disabled; 
    ADCON2L = 0x00;
    // SHRSAMC 318; 
    ADCON2H = 0x13E;
    // SWCTRG disabled; SHRSAMP disabled; SUSPEND disabled; SWLCTRG disabled; SUSPCIE disabled; CNVCHSEL AN0; REFSEL disabled; 
    ADCON3L = 0x00;
    // SHREN enabled; C1EN disabled; C0EN disabled; CLKDIV 1; CLKSEL FOSC; 
    ADCON3H = (0x4080 & 0xFF00); //Disabling C0EN, C1EN, C2EN, C3EN and SHREN bits
    // SAMC0EN disabled; SAMC1EN disabled; 
    ADCON4L = 0x00;
    // C0CHS AN0; C1CHS AN1; 
    ADCON4H = 0x00;
    // 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; 
    ADMOD0L = 0x00;
    // 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; 
    ADMOD0H = 0x00;
    // 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; 
    ADMOD1L = 0x00;
    // SIGN24 disabled; DIFF25 disabled; DIFF24 disabled; SIGN25 disabled; 
    ADMOD1H = 0x00;
    // 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; 
    ADIEL = 0x00;
    // IE17 disabled; IE18 disabled; IE16 disabled; IE19 disabled; IE20 disabled; IE21 disabled; IE24 enabled; IE25 enabled; IE22 enabled; IE23 disabled; 
    ADIEH = 0x340;
    // 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; 
    ADCMP0ENL = 0x00;
    // 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; 
    ADCMP1ENL = 0x00;
    // 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; 
    ADCMP2ENL = 0x00;
    // 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; 
    ADCMP3ENL = 0x00;
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 
    ADCMP0ENH = 0x00;
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 
    ADCMP1ENH = 0x00;
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 
    ADCMP2ENH = 0x00;
    // CMPEN21 disabled; CMPEN22 disabled; CMPEN20 disabled; CMPEN18 disabled; CMPEN19 disabled; CMPEN16 disabled; CMPEN17 disabled; CMPEN25 disabled; CMPEN23 disabled; CMPEN24 disabled; 
    ADCMP3ENH = 0x00;
    // CMPLO 0; 
    ADCMP0LO = 0x00;
    // CMPLO 0; 
    ADCMP1LO = 0x00;
    // CMPLO 0; 
    ADCMP2LO = 0x00;
    // CMPLO 0; 
    ADCMP3LO = 0x00;
    // CMPHI 3; 
    ADCMP0HI = 0x03;
    // CMPHI 0; 
    ADCMP1HI = 0x00;
    // CMPHI 0; 
    ADCMP2HI = 0x00;
    // CMPHI 0; 
    ADCMP3HI = 0x00;
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 
    ADFL0CON = 0x400;
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 
    ADFL1CON = 0x400;
    // OVRSAM 16x; MODE Oversampling Mode; FLCHSEL AN0; IE disabled; FLEN disabled; 
    ADFL2CON = 0xC00;
    // OVRSAM 4x; MODE Oversampling Mode; FLCHSEL AN22; IE disabled; FLEN enabled; 
    ADFL3CON = 0x8416;
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 
    ADCMP0CON = 0x00;
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 
    ADCMP1CON = 0x00;
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 
    ADCMP2CON = 0x00;
    // HIHI disabled; LOLO disabled; HILO disabled; BTWN disabled; LOHI disabled; CMPEN disabled; IE disabled; 
    ADCMP3CON = 0x00;
    // 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; 
    ADLVLTRGL = 0x00;
    // LVLEN20 disabled; LVLEN22 disabled; LVLEN21 disabled; LVLEN24 disabled; LVLEN23 disabled; LVLEN25 disabled; LVLEN17 disabled; LVLEN16 disabled; LVLEN19 disabled; LVLEN18 disabled; 
    ADLVLTRGH = 0x00;
    // SAMC 0; 
    ADCORE0L = 0x00;
    // SAMC 0; 
    ADCORE1L = 0x00;
    // RES 12-bit resolution; EISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; ADCS 2; 
    ADCORE0H = 0x300;
    // RES 12-bit resolution; EISEL Early interrupt is generated 1 TADCORE clock prior to data being ready; ADCS 2; 
    ADCORE1H = 0x300;
    // 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; 
    ADEIEL = 0x00;
    // EIEN17 disabled; EIEN16 disabled; EIEN25 disabled; EIEN19 disabled; EIEN18 disabled; EIEN20 disabled; EIEN24 disabled; EIEN23 disabled; EIEN22 disabled; EIEN21 disabled; 
    ADEIEH = 0x00;
    // C0CIE disabled; C1CIE disabled; SHRCIE disabled; WARMTIME 32768 Source Clock Periods; 
    ADCON5H = (0xF00 & 0xF0FF); //Disabling WARMTIME bit
  
    //Assign Default Callbacks
    ADC1_SetCommonInterruptHandler(&ADC1_CallBack);
    ADC1_SetUoutInterruptHandler(&ADC1_Uout_CallBack);
    ADC1_Setchannel_AN24InterruptHandler(&ADC1_channel_AN24_CallBack);
    ADC1_Setchannel_AN25InterruptHandler(&ADC1_channel_AN25_CallBack);
    
    // Clearing Uout interrupt flag.
    IFS7bits.ADCAN22IF = 0;
    // Enabling Uout interrupt.
    IEC7bits.ADCAN22IE = 1;
    // Clearing channel_AN24 interrupt flag.
    IFS12bits.ADCAN24IF = 0;
    // Enabling channel_AN24 interrupt.
    IEC12bits.ADCAN24IE = 1;
    // Clearing channel_AN25 interrupt flag.
    IFS12bits.ADCAN25IF = 0;
    // Enabling channel_AN25 interrupt.
    IEC12bits.ADCAN25IE = 1;

    // Setting WARMTIME bit
    ADCON5Hbits.WARMTIME = 0xF;
    // Enabling ADC Module
    ADCON1Lbits.ADON = 0x1;
    // Enabling Power for the Shared Core
    ADC1_SharedCorePowerEnable();

    //TRGSRC0 Common Software Trigger; TRGSRC1 None; 
    ADTRIG0L = 0x01;
    //TRGSRC3 None; TRGSRC2 None; 
    ADTRIG0H = 0x00;
    //TRGSRC4 None; TRGSRC5 None; 
    ADTRIG1L = 0x00;
    //TRGSRC6 None; TRGSRC7 None; 
    ADTRIG1H = 0x00;
    //TRGSRC8 None; TRGSRC9 None; 
    ADTRIG2L = 0x00;
    //TRGSRC11 None; TRGSRC10 None; 
    ADTRIG2H = 0x00;
    //TRGSRC13 None; TRGSRC12 None; 
    ADTRIG3L = 0x00;
    //TRGSRC15 None; TRGSRC14 None; 
    ADTRIG3H = 0x00;
    //TRGSRC17 None; TRGSRC16 None; 
    ADTRIG4L = 0x00;
    //TRGSRC19 None; TRGSRC18 None; 
    ADTRIG4H = 0x00;
    //TRGSRC20 None; TRGSRC21 None; 
    ADTRIG5L = 0x00;
    //TRGSRC22 Common Software Trigger; TRGSRC23 None; 
    ADTRIG5H = 0x01;
    //TRGSRC24 Common Software Trigger; TRGSRC25 Common Software Trigger; 
    ADTRIG6L = 0x101;
}

Hier die Funktion für den ADC

void ADC1_Core0PowerEnable ( ) 
{
    ADCON5Lbits.C0PWR = 1; 
    while(ADCON5Lbits.C0RDY == 0);
    ADCON3Hbits.C0EN = 1;     
}

void ADC1_Core1PowerEnable ( ) 
{
    ADCON5Lbits.C1PWR = 1; 
    while(ADCON5Lbits.C1RDY == 0);
    ADCON3Hbits.C1EN = 1;     
}

void ADC1_SharedCorePowerEnable ( ) 
{
    ADCON5Lbits.SHRPWR = 1;   
    while(ADCON5Lbits.SHRRDY == 0);
    ADCON3Hbits.SHREN = 1;   
}


void __attribute__ ((weak)) ADC1_CallBack ( void )
{ 

}

void ADC1_SetCommonInterruptHandler(void* handler)
{
    ADC1_CommonDefaultInterruptHandler = handler;
}

void __attribute__ ((weak)) ADC1_Tasks ( void )
{
    if(IFS5bits.ADCIF)
    {
        if(ADC1_CommonDefaultInterruptHandler) 
        { 
            ADC1_CommonDefaultInterruptHandler(); 
        }

        // clear the ADC1 interrupt flag
        IFS5bits.ADCIF = 0;
    }
}

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

}

void ADC1_SetUoutInterruptHandler(void* handler)
{
    ADC1_UoutDefaultInterruptHandler = handler;
}

void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN22Interrupt ( void )
{
    uint16_t valUout;
    //Read the ADC value from the ADCBUF
    valUout = ADCBUF22;

    if(ADC1_UoutDefaultInterruptHandler) 
    { 
        ADC1_UoutDefaultInterruptHandler(valUout); 
    }

    //clear the Uout interrupt flag
    IFS7bits.ADCAN22IF = 0;
}

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

}

void ADC1_Setchannel_AN24InterruptHandler(void* handler)
{
    ADC1_channel_AN24DefaultInterruptHandler = handler;
}

void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN24Interrupt ( void )
{
    uint16_t valchannel_AN24;
    //Read the ADC value from the ADCBUF
    valchannel_AN24 = ADCBUF24;

    if(ADC1_channel_AN24DefaultInterruptHandler) 
    { 
        ADC1_channel_AN24DefaultInterruptHandler(valchannel_AN24); 
    }

    //clear the channel_AN24 interrupt flag
    IFS12bits.ADCAN24IF = 0;
}

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

}

void ADC1_Setchannel_AN25InterruptHandler(void* handler)
{
    ADC1_channel_AN25DefaultInterruptHandler = handler;
}

void __attribute__ ( ( __interrupt__ , auto_psv, weak ) ) _ADCAN25Interrupt ( void )
{
    uint16_t valchannel_AN25;
    //Read the ADC value from the ADCBUF
    valchannel_AN25 = ADCBUF25;

    if(ADC1_channel_AN25DefaultInterruptHandler) 
    { 
        ADC1_channel_AN25DefaultInterruptHandler(valchannel_AN25); 
    }

    //clear the channel_AN25 interrupt flag
    IFS12bits.ADCAN25IF = 0;
}

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

[Teo D. (teoderix)]

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.... ;)

[K. (yberion45)]

Da ich nur zwei Volt gebe könnte ich den Funktionsgenerator auch direkt 
an AN und GND_A anschließen. Meine aber auch da waren Sprünge zu sehen, 
daher dachte ich durch den Spannungsteiler kann ich das was beruhigen

[K. (yberion45)]

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.

[K. (yberion45)]

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

[Thomas Z. (usbman)]

printf im ADC Interrupt.

Mehr gibt es nicht zu sagen oder?

[K. (yberion45)]

Thomas Z. schrieb:
> printf im ADC Interrupt.
>
> Mehr gibt es nicht zu sagen oder?

Es wäre super wenn das erklärst?

Auch mit printf außerhalb des Interrupt bleibt es gleich. Die Spannung 
springt...

[Thomas Z. (usbman)]

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.

[K. (yberion45)]

danke werde ich versuchen!

Hab leider kein Oszi bis Montag, da Uni mir die nicht ausleihen will ^^ 
zu teuer. Hab nur Fluke Messgerät hier.

Danke für die Erklärung

[K. (yberion45)]

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