Hallo iedereen,

Voor het project voor school moet ik het volgende gaan doen ik moet twee spanningen inlezen die frequentieafhankelijk zijn maar dat doet er nu niet toe wil het eerst wat eenvoudig houden.

De setup van de interne ADC dat is het probleem niet heb dus voor Vin = AN0 en voor Vout = AN1 ingesteld.

Alles wordt met een interrupts gestuurd dus ik test de ADIF vlag en daarna clear ik die onmiddelijk om terug interrupts toe te laten.

Ik lees mijn eerste waarde in AN0 dus Vin, dan ga ik na een bepaalde delta t AN1 inlezen en na die conversie een interrupt veroorzaken om dan het resultaat weg te schrijven

Daar loopt het spaak want heb nu geen idee wat ik met die twee resultaten moet doen.

Ik heb het volgende berekend:

Een 10 bits ADC dus 0..1023 stappen en een Vref = 3V

(Vin / Vref) * 1024 = result_0
(Vout / Vref) * 1024 = result_1

Dan neem ik het verschil van beide resultaten en doe dan een if en vergelijk dat maar met wat en dat weet ik niet, misschien met een lookup table.

We maken een bodeplotter en willen dat via microcontroller daarna via de PC een grafische interface maken met grafieken

Weten jullie als mijn redenering hier juist is?
Ik programmeer in microC en stukje assembler

Ik maak gebruik van het ADIF interrupt, een microcontroller 18F2550 en de interne ADC van 10bits

Ps: hier zitten broers op en ja we doen dezelfde richting dus geen vragen stellen daarover

Ik wil gewoon hebben dat deze week mijn ADC die waarden kan inlezen en daarna kan sturen via de UART nog in testfase eerst zien als dat werkt

Ik maak gebruik van een development board van Mikroelektronika

Het probleem van die MUX is nu van de baan.

Wat nu nog het probleem is hoe stuur ik deze DDS aan want wil nu een Master Slave maken.

Ik denk het zo te doen:

1) Initialiseren van de SPI module van de microcontroller
2) Eenmalig het control register initialiseren
3) Frequentie instellen en doorsturen via SPI naar het frequentie register om het DDS in te stellen

Mijn vraag is nu kan ik die frequenties opslaan in een lookup table en dan in een for lus elke frequentie ophalen en er bewerkingen mee doen bvb stap per 1000Hz, 10Hz, 1Hz.?

[Bericht gewijzigd door ElectronicsVibes op (14%)]

Op 24 maart 2009 00:11:18 schreef ElectronicsVibes:
(Vin / Vref) * 1024 = result_0
(Vout / Vref) * 1024 = result_1

Dan neem ik het verschil van beide resultaten en doe dan een if en vergelijk dat maar met wat en dat weet ik niet, misschien met een lookup table.

Ojee.. Je gaat eerst integers omzetten naar floats via een moeilijke berekening om vervolgens de float op te zoeken in een lookup table?

Trek gewoon Vin van Vout af (of andersom) en zoek met dat resultaat iets op in een lookup table. Die extra tussenstap is zinloos en vreet code / tijd.

Snap niet echt wat je bedoeld misschien kan een voorbeeld duidelijker zijn voor mij.

Wat jij bedoeld is dat je AN1 - AN0 vanelkaar moet aftrekken maar daar kan ik toch niet aan want het is intern die ADC in de microcontroller krijgt enkel dat resultaat in adresh en adresl wat in C bvb in een temp variabele steek

Snap niet goed hoe ik het verschil moet maken en met wat moet ik dan vergelijken, het zijn amplitudes die ik meet

Vin wordt aangesloten aan mijn DUT (freq afhankelijk netwerkje) en de uitgang van die DUT staat mijn Vout aangesloten en deze spanningen stuur ik dan naar AN0 (Vin) en AN1 (Vout)

Kan je wat meer uitleg geven want snap het echt niet wat je bedoeld aangezien ik toch niet aan de ingangen kan

En wat ik ook niet snap hoe ga ik na een bepaalde tijd naar kanaal 1 als ik eerst kanaal 0 heb ingelezen om dan terug kanaal 0 in te lezen?

Bedoeling is telkens een sample te nemen door van een bepaalde frequentie, dus bvb 0Hz neem ik een sample enz tot 20kHz maar wel single conversion

Je kunt ze toch ook delen door 1024, waarom kan dàt dan wel als je er niet aan kunt?
Vout - Vin = result

Bestudeer eerst eens in de pic-datasheet het gedeelte over de ADC in detail.
Gezien je opmerkingen over de ADIF /ADinterrupt / channel selection denk ik dat het dan al een stuk duidelijker voor je wordt.

Zonnepaneeltje

Ik heb die manual al 10 keer gelezen en er brandt geen lichtje ik probeer het volgende: de initialisatie laat ik wel weg hier maar heb eerst alles ingesteld natuurlijk om met twee kanalen te werken van de interne ADC



// Global variables
extern const char CHIP_SEL;
unsigned int temp_res;
unsigned short temp;

void interrupt()
{
    if(PIR1.ADIF == 1)
    {
       PIR1.ADIF = 0;
       // =====================================
       // Interrupt Service Routine ADC Module
       // =====================================
       PORTA.F5 = 1;
       temp_res = 0;
       do
       {
         PIE1.ADIE = 1;
         PORTC.F1   = 1;
         temp_res   = Adc_Read(0);        // Get results of AD conversion
         PORTB      = temp_res;           // Send lower 8 bits to PORTD
         PORTB      = temp_res >> 2;      // Send 2 most significant bits to RB7, RB6
         Delay_us(20);
         temp_res   = Adc_Read(1);        // Get results of AD conversion
         PORTB      = temp_res;           // Send lower 8 bits to PORTD
         PORTB      = temp_res >> 2;      // Send 2 most significant bits to RB7, RB6
         Delay_us(20);
       }
        while(1);
    }
}

Dat is mijn eerste test, moet ik die kanalan veranderen in de code of gebeurt dat autoamtisch want dat staat nergens in die datasheet

Graag een voorbeeldcode hoe je die twee kanalan aanstuurt dat heeft mij dan een aanzet verder te programmeren, een duwtje helpt steeds want we hebben een ADC in theorie gezien maar niet praktisch

Ik begrijp de opdracht niet zo goed; maar volgens mij is een bodeplot toch een frequentie / Amplicfication diagram?
Je zal dus Vout / Vin nodig hebben denk ik; maw hoeveel is de versterking? Daarna zal je die versterking moeten omzetten naar DB. 20* log (Vout/Vin).

Ik zou dus eerst eens beginnen met hetvolgende:

- Controleer of je ADC conversie gewoon werkt. 10 bits dus je resultaat is een int16 (2 byte). Stuur die door naar de PC serieel en kijk als je deze waarde terug kan omzetten naar je analoge spanning:
Vanaloog = ADC_READING * ( Vcc of Vref / 1023 )

Maak nu eens een programma dat om de seconde die waarde omzet en doorstuurt en controleer. Daarna zien we wel verder.

een paar puntjes mbt. je code:
- een ISR die niet met een return eindigt, maar in een eindeloze lus blijft hangen.
- Delays in de ISR.
ik zou de ISR anders maken.

nog een paar andere vragen:
- Waar wordt de frequentie-as van het bode-diagram bepaald, welke verhouding Vout/Vin hoort bij welke frequentie ?
- Hoe zit het met de fase tussen Vout en Vin ? die is bij een bodeplot toch ook belangrijk ?

Hallo,

Mijn taak is enkel Vin en Vout in te lezen, daarna het resultaat door te sturen via USART.

De omzetting van een log schaal of een linaire schaal gebeurt aan de PC kant en dat is mijn taak niet.

Ik ben toch juist dat ik twee kanalen gebruik AN0 (Vin) en AN1 (Vout) en ja dan moet ik dit resultaat (Vout/Vin) * 1024 als ik het goed voor heb

Dus die 20 log moet ik dus niet doen enkel dan het resultaat via de USART doorsturen

Nu hoe kan ik controleren dat mijn conversie werkt met die twee kanalen want je hebt toch enkel ADRESH en ADRESL en daar loop ik vast, waar sla ik die twee resultaten op die ik heb ingelezen in AN0 en AN1???

Ik heb al de volgende functies geschreven en ja alles is interrupt gestuurd

void OpenADC( unsigned char config, unsigned char config2);
void SetChannelADC(unsigned char channel);
char BusyADC(void);
void ConvertADC(void);
int ReadADC(void);
void CloseADC(void);

Eén kanaal inlezen geen probleem mee maar hoe gaat dat met meerdere kanalen?

Dus ik heb het volgende gedaan:

Ik kan met een eenvoudig programma één kanaal inlezen en daarna doorsturen via de USART en heb geen timer daarvoor nodig want heb vertragingen in MicroC

PC serieel en kijk als je deze waarde terug kan omzetten naar je analoge spanning:
Vanaloog = ADC_READING * ( Vcc of Vref / 1023 )

Ik ben hier iets verder aan het bestuderen een h file die op nergens slaat en helemaal verkeerd is

Ik neem de datasheet van de PIC18F2550 en neem de rubriek ADC en neem bvb het register 2

Ik heb de volgende include file van microchip:

#ifndef __ADC_H
#define __ADC_H

/* PIC18 A/D conversion peripheral library. */

/*
* The following configuration masks are to be bitwise 'anded' together and
* passed as parameters to the 'open' routines. See the 'open' routine
* prototypes below for more information.
*/

/* ***** clock source ***** */
#define ADC_FOSC_2 0b10001111 // A/D clock source Fosc/2
#define ADC_FOSC_4 0b11001111 // A/D clock source Fosc/4
#define ADC_FOSC_8 0b10011111 // A/D clock source Fosc/8
#define ADC_FOSC_16 0b11011111 // A/D clock source Fosc/16
#define ADC_FOSC_32 0b10101111 // A/D clock source Fosc/32
#define ADC_FOSC_64 0b11101111 // A/D clock source Fosc/64
#define ADC_FOSC_RC 0b11111111 // A/D clock source Internal RC OSC

Wat ik niet begrijp: ik neem bvb AD clock source Fosc/64

Als ik in de datasheets kijk dan krijg ik het volgende:

11111110 volgens de datasheet
in de include file lees ik 11101111 hoe verklaar men dit?
Klopt dat wel in die include file?

OK, als ik de opdracht goed begrijp moet je om de X tijd samples nemen van Vin en Vout en die serieel doorsturen naar de PC? Op de PC zet je die waarden om naar DB's dan? Is het dat?

Ik zou dat zo aanpakken.

1. Om de X tijd iets doen = een timer starten die om de X tijd overloopt, je krijgt dan een timer overflow interrupt. DAAR MOET JE EEN VLAG ZETTEN; bijv. 1_SEC_passed = TRUE.
In je main check je die vlag:

main {

while (TRUE)
{
if (1_SEC_PASSED == TRUE){
1_SEC_PASSED = FALSE;
// Lees nu je Vin en Vout in en stuur die door naar de PC.
}
}
}

Een andere vraag; moet jij met 10 bits resolutie werken? Je kan ook met 8 bits hé, dan moet je maar 1 byte doorsturen.
Anders heb je 2 bytes als resultaat (adres_L en adres_H) en moet je beiden doorsturen.

Welke taal gebruik je en welke compiler heb je? Ik zou wel niet met ASM werken. Ik kan je een voorbeeldje sturen hoe ik het doe in CCS:


//********************************* FUNCIES **********************************//
//*********************** ADC: Meten Spanning (10bit) ************************//
// Vbat = (150+120)/120*waarde*3/1023
int16 Meet_Spanning_2 (int1 mode)
{
   int16 ADC_reading; 
   setup_adc_ports (AN0_AN1_AN3);
   setup_adc (ADC_CLOCK_DIV_32);
   set_adc_channel ( mode );          // Vbat op RA0; Vadap op RA1
   delay_us (20);
   ADC_Reading = read_adc();
   setup_adc (ADC_OFF);
   setup_adc_ports (NO_ANALOGS);
   return ADC_Reading;
}

[Bericht gewijzigd door Henry S. op (1%)]

Tech_Makes_Sense

Met een Timer moet ik niet werken van de docent is nrmaal niet nodig enkel enkel de TAD in rekening brengen

Ja dat is juist na een delta t moet ik samples nemen van zowel Vin (AN0) en Vout (AN1) en dit resultaat serial versturen met ingebouwde functies en alles met interrupts
dus mijn hoofdprogramma is wat initialisaties, daarna een oneindige lus en wacht op interrupts

Dus zou het probleem willen zo aanpakken:

STAP1
Frequentie instellen van de DDS door het sturen van een frequentiewoord en dit via het SPI protocol.

STAP2
Na een bepaalde tijd gaan we de amplitude meten van de ingangspanning (AN0) en de uitgangspanning (AN1)
We doen een single conversion door de volgende bits in te stellen : ADON (bit0) en GO/DONE (bit1)
Na een bepaalde tijd treedt er een interrupt op ADIF = 1 en wordt een serial transmit uitgevoerd.

Volgorde van programmeren:
STAP 1 Amplitude meten van beide ingangen na interrupt versturen van de informatie via de UART module
STAP 2 Na de interrupt van de ADC de data serieel versturen via de UART
STAP 3 Frequentie instellen van de DDS via het SPI protocol

Dus in mijn hoofdprogramma mag maar dat staan:

void interrupt()
{
if(PIR1.ADIF == 1)
{
PIR1.ADIF = 0;
// Lees nu je Vin en Vout
// Dat is mijn vraag hoe want je hebt toch twee
// kanalen dus graag een voorbeeld bij gebruik van
// twee kanalen van de ADC
}

void main()
{
init_mcu();
init_dds();
while(1);
}

Ja ik moet met 1à bits resolutie werken daar ik het audiogebied moet scannen van 0Hz tot 20kHz en heb een fs genomen van 60kHz

Ik gebruik microC dat is de ANSI C voor PIC16 en PIC18 en hoger microcontrollers

In mijn geval de MicroC compiler registreerde volledige versie

Ik zou het erg leuk vinden dat ik vandaag die Vout en Vin willen inlezen en dan ergens in een variabele opslaan en eens een meting dan met de scoop als ik aan die twee potmeters draai om te simuleren van Vin en Vout

Je haalt volgens mij heel wat zaken door elkaar.

die ADIF interrupt, wat is dat? Is dat een interrupt die zegt dat de ADC conversie voltooid is? En waar start je die? En om de hoeveel tijd start je die?

heb je al eens gezocht naar microC voorbeelden van een ADC conversie?

Post eens heel je programma en gebruik de

 tags.

Eerst op je vragen antwoorden:

Ik gebruik de microcontroller 18F2550 die heeft een interne 10 bits ADC aan boord met 10 channels in de 28 pin versie want die gebruik ik

De volgende bits zijn belangrijk bij een ADC converie:

Als de A/D conversie klaar is, wordt het resultaat getransfereerd naar de ADRESH & ADRESL registers, wordt de GO-/DONE bit (ADCON0) gewist en wordt de A/D Interrupt Flag bit ADIF geset

Start de conversie :
Set de GO-/DONE bit (ADCON0)

Wacht op het einde van de conversie, door :
Het wachten op de A/D interrupt

Lees het A/D Result registers uit (ADRESH:ADRESL), wis de ADIF bit, indien vereist

hier mijn voorlopige code: init staan in de main()



void interrupt()
{
   if(PIR1.ADIF == 1)
   {
      PIR1.ADIF = 0;
      isr_adc();
   }
}

void isr_adc()
{
  unsigned int Vout, Vin;
  unsigned int temp;
  
  Vin  = ADC_Read(0);        // Get results of Vin chan 0
  Delay_us(20);
  Vout = ADC_Read(1);        // Get results of Vout chan 1
  Delay_us(30);

  temp = (int) (Vout / Vin); // G = (Vout/Vin)

  PORTD = temp_res;          // Send lower 8 bits to PORTD
  PORTB = temp_res >> 2;     // Send 2 most significant bits to RB7, RB6
}

void main() {
  init_mcu();
  init_adc();
  init_usart();
  while(1);                 // wait for interrupts
}

Wanneer wordt die void interrupt () gelaunched?
Die deling zou ik niet doen; je moet gewoon het resultaat van de conversie doorsturen naar de PC en daar die 2 bytes verwerken.
Waarom zet je die temp_res op je poort?

Post eens je volledig programma; of is dit het?

Mijn volledige programma maar nog niet modulair opgebouwd en dat zou ik graag ook doen:



unsigned int Vin, Vout, myVal;

void main() {
  USART_Init(9600);  // Initalize USART (9600 baud rate, 1 stop bit, ...

  // Select Vref and analog inputs, in order to use ADC_Read
  ADCON1 = 0;        // All porta pins as analog, VDD as Vref
  TRISA  = 0xFF;     // PORTA is input
  TRISB  = 0xF5;
  

  do {

    // Read ADC results and send via UART
    Vin = ADC_Read(0);

    // Testen 
    if(Vin > 2)
       PORTB.F3 = 1;
    else
       PORTB.F1 = 1;
    
       
    USART_Write(Lo(Vin));   // Send lower 8 bits to UART
    USART_Write(Hi(Vin));   // Send upper 8 bits to UART

    Vout = ADC_Read(1);
    USART_Write(Lo(Vout));   // Send lower 8 bits to UART
    USART_Write(Hi(Vout));   // Send upper 8 bits to UART

    myVal = Vin/Vout;
    USART_Write(Lo(myVal));   // Send lower 8 bits to UART
    USART_Write(Hi(myVal));   // Send upper 8 bits to UART
  } while (1);       // endless loop
}

Kan ik nu dat stukje in de functie interrupt plaatsen en zo het hoofdprogramma leeg laten, dus enkel de init en die endless loop die wacht op interrupts?

Ok en werkt dit programma?
Die deling moet je niet doorsturen maar op de PC uitvoeren.

Waarom zet je die B3 / B1 hoog ? Die gaan dus steeds hoog blijven hé.

Ik begrijp niet wat je wil doen met die interrupts? Je hebt die toch helemaal niet nodig?
Je moet wel een kleine delay plaatsen na je Read_ADC operatie.

Hallo Tech_Makes_Sense,

Ja van de RB1 en RB3 moeten laag staan, dat is gewoon een test meer niet

Ik ga hier eens mijn opgave neerpoten:

Bodediagram Plotter met microcontroller
=======================================

1. Blokschema
-------------

Een DUT, waarvan de uitgangspanning gemeten zal worden over een gedefinieerd frequentiebereik 0Hz tot 20kHz

Een VCO, die aangestuurd wordt door een zaagtandspanning
waarvan de amplitude lineair/log wijzigt tussen twee spanningsniveaus

Een Bode Plot Measurement Unit, die realtime de ingang - en uitgangspanning van de DUT meet en verwerkt.

Een serial Interface, die de meetgegevens volgens een bepaald protocol uitwisselt met de laptop

Verklaring :
============

A. Device Under Test
--------------------
Kan een elektronisch component, circuit of toestel zijn, waarvan de uitgangsamplitude frequentieafhankelijk is.

B. Bode plot Measurement Unit
-----------------------------
- het realtime meten, digitaliseren en verwerken van de Vin van de DUT
- het realtime meten, digitaliseren en verwerken van de Vout van de DUT

Dit wordt gedaan door een microcontroller PIC18F2550 met een interne 10 bits ADC

Het aansturen van de VCO, om de frequentie, amplitude van het ingangssignaal in te stellen

Dit wordt gedaan door een Direct Digital Interface Unit een DDS van het type AD9833

Het lineair/logaritmisch doorlopen van de frequentieband
Het verwerken van de gemeten spanningen

Kan ik dat doen met de microcontroller of liever via de laptop?

Het serial versturen naar Laptop van de meetgegevens

Dit wordt gedaan door de ingebouwde functies aan te roepen van de USART van de microcontroller

Synchronisatie en communicatie tussen de hardware en de software.

Hoe kan ik dat hier verwezenlijken: bedoelen ze daarmee de asynchrone communicatie met RS232?

Het kalibreren van de meting.

Op het moment dat de conversie is gedaan moet er een interrupt worden gegeven voor het sturen van de meetdata via mijn USART en omgekeerd vandaar die interrupt

Maar hoe deel ik dat zo in want ik werk modulair dat ik alles afzonderlijk kan testen als één geheel

DC2PCC,

Eens op je vragen antwoorden:

Jij zegt dat je die interrupt service routine anders zou plaatsen waar zou je die plaatsen want interrupt() hoort steeds bij de main() kan je niet in andere module zetten wel de ISR routines die je aanroept.

Ik wil graag de modulaire aanpak blijven volgen.

Hoe bedoel je met delays in de ISR?

De frequentieas van het bode diagram wordt gedaan door mijn andere collega die de software voor de PC verzorgt
Ik hoef enkel de raw data te sturen.

Geef eens een voorbeeld: wat je bedoeld "welke verhouding Vout/Vin hoort bij welke frequentie? Moet ik dat verzorgen aan de microcontroller zijde of geef ik dat aan mijn medestudent die het programma voor de GUI schrijft?

De fase moeten we niet doen in onze opdracht

Waarom postte je dit niet van in het begin ? Nu is alles een stuk duidelijker. Is dit een stageproject of een lab-opdracht? 'k Vind 't wel een knap project!

Ok, dit is hoe ik dit zou aanpakken. Ik zou alles één voor één opbouwen. Telkens iets werkt, kan je aan de volgende module beginnen. Maak ook altijd backups van je werk.

1. Je moet dus volgende RAW data (= de verwerking en berekening gebeurt op de PC) doorsturen naar de PC:
- De frequentie van het ingangsignaal
- De amplitude van het Vin
- De amplitude van Vout
Want dat is wat een bodeplot weergeeft: de versterking bij een bepaalde frequentie.

Ik zou beginnen met het meten van de frequentie. Dit kan kan wslk via die DDS chip daar? Probeer die eens uit te lezen en dan gewoon serieel door te sturen naar de PC. Kijk eens als die uitlezing klopt.

Hallo

Het is een lab project maar echt knap wel daarom wil ik het laten slagen vandaar mijn 200% inzet.

Zou ik nog iets doen aan de code die ik heb geschreven voor het inlezen van beide analoge waarden en dan die raw data sturen kan ik dat beschouwen als één stukje.

Ik heb reeds de volgende code geschreven voor het instellen van de frequentie van het SPI protocol:



// Addressing AD9833
#define   FREQ0     0x4000        // Address Freq0 = 0100 0000 0000 0000
#define   FREQ1     0x8000        // Address Freq1 = 1000 0000 0000 0000

// AD9833 Control Register bits
#define   B28      (1 << 13)      // bit 13 B28
#define   HLB      (1 << 12)      // bit 12 HLB
#define   FSELECT  (1 << 11)      // bit 11 FSELECT
#define   RESET    (1 << 8)       // bit 8 RESET
#define   OPBITEN  (1 << 5)       // bit 5 OPBITEN
#define   MODE     (1)

#define 	SINE		    0
#define		TRIANGLE	  1
#define   MCLK 		    25000000
#define	  FREQ_STEP	(MCLK  /  2^28)


// Functie prototypes
void Write_AD9833(unsigned int waarde);
void Set_DDS_Frequency(float Freq);
void Reset_AD9833();
void Output_high(unsigned FSYNC);
void Output_low(unsigned FSYNC);

//void Write_AD9833(unsigned int waarde)
//{
//   unsigned short cmd_lsb, cmd_msb;
//
//   cmd_lsb = (int) waarde;
//   cmd_msb = waarde >> 8;
//   output_low(FSYNC);
//   delay_us(5);
//   spi_write(cmd_msb);
//   spi_write(cmd_lsb);
//   delay_us(5);
//   output_high(FSYNC);
//}

//void Reset_AD9833()
//{
//   Write_AD9833(B28|RESET|OPBITEN);    // Reset
//   Write_AD9833(B28&OPBITEN&MODE);     // Sine Wave
//}
//
//void Set_DDS_Frequency(unsigned short Freq)
//{
//   unsigned long i, LSB, MSB;
//
//   Freq /= FREQ_STEP;
//   i = (unsigned long) Freq;
//   LSB = (i & 0x3FFF) + FREQ0;
//   MSB = (i >> 24) & 0x3FFF) + FREQ0;
//   Write_AD9833(LSB);
//   Write_AD9833(MSB);
//}
//
//void DDS_Init(void)
//{
//   DDS_DDR |= DDS_DATA + DDS_SCLK + DDS_SCS + DDS_LOWOUTPUT;
//   DDS_PORT |= DDS_DATA +  DDS_SCLK + DDS_SCS;
//   DDS_Write(0x2100);                                // Reset
//   DDS_Write(0x2002);                               // Normal mode
//   DDS_Write(0x2000);                               // Sinwave
//}
//
//void DDS_Write(unsigned int)
//{
//    signed char i;
//    DDS_PORT &=~DDS_FSYNC;				//
//    DDS_Delay();
//    for(i = 15; i ! -1; i--)
//    {
//       If(Write &(1 << i)
//           DDS_PORT |= DDS_DATA;
//       else
//          DDS_PORT &= ~DDS_DATA;
//      DDS_Delay();
//      DDS_PORT &=  ~DDS_SCLK;
//      DDS_Delay();
//      DDS_PORT |=  ~DDS_SCLK;
//   }
//   DDS_Delay();
//   DDS_PORT |= DDS_FYNC;
//}
//
//Void DDS_Delay( void)
//{
//   unsigned i;
//  for(i = 0; i < 100; i++) WDT();
//}

Mijn vraag in welke volgorde zou ik die aansturen?

OK, je moet dus zelf de frequentie instellen van die generator. Dan moet je die al niet meten. Frequentie zal je dan ook naar de PC moeten sturen hé.

Leg nog eens apart het verschil uit tussen die AD9833 en die DDS?

Heb je daar een schema van en van de rest? Dat zegt dikwijls meer dan woorden.

Hallo

Bedankt steeds voor je snelle antwoorden:

DDS is een afkorting van Direct Digital Synthesis

http://en.wikipedia.org/wiki/Direct_digital_synthesis

Datasheet van de AD9833 (25MHz) of AD9835 (50MHz)

http://www.analog.com/static/imported-files/data_sheets/AD9833.pdf

http://www.analog.com/static/imported-files/data_sheets/AD9835.pdf

Met vriendelijke groet

Hallo

Ik kan deze enkel naar je emailen maar hier plaatsen niet want heb er mijn werk ingestoken

Het bestaat uit dat evaluaieboard die je vind in de datasheet en een schema van de PIC met een MAX232

We hebben enkel een globaal blokschema gehad dus moeten we het zelf uitwerken