ATNEL tech-forum 2013-04-19T14:32:46+01:00 https://forum.atnel.pl/feed.php?f=4&t=1555&mode 2013-04-19T14:32:46+01:00 2013-04-19T14:32:46+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34719#p34719 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
Biblioteki zrobiłem, że czasowe zależności już są lepsze
[syntax=c]void load_dac_A(uint16_t DAC_A_data){
uint8_t MX_flags = 0;
// załaduj LSB
PORT(MX_PORT) = DAC_A_data;

MX_flags |= (1<<MX_CLR) | (1<<MX_UPD) | (1<<MX_CS) | (1<<MX_WR) | (0<<MX_A1) | (0<<MX_A0);
PORT(MX_FLAGS) = MX_flags;

CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_WR;

// Załaduj MSB
PORT(MX_PORT) = DAC_A_data >> 8;
MX_flags |= (1<<MX_CLR) | (1<<MX_UPD) | (1<<MX_CS) | (1<<MX_WR) | (0<<MX_A1) | (1<<MX_A0);
PORT(MX_FLAGS) = MX_flags;

CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_WR;
CLR_MX_A0;
update_MXregister();
}[/syntax]

Chwilowo musiałem zostawić jednak kasowanie Bitów na piechotę, gdyż zależności czasowe jednak mają znaczenie przy zegarze 11059200, dokładniej chodzi o kolejność włączania i kasowania WR w stosunku do CS i UPD.

Statystyki: Napisane przez Gość — 19 kwi 2013, o 14:32

]]> 2013-04-19T11:30:31+01:00 2013-04-19T11:30:31+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34701#p34701 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> . Dzięki Mirku zainspirowałeś mnie do przejrzenia tej obsługi step-by-step ;)

[syntax=c]/*
* MX7537.c
*
* Created on: 17-04-2013
* Author: Sylwester Taras
*/

#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#include "MX7537.h"
// makrodefinicje operacji na sygnałach sterujących CLR, UPD, WR, CS, A0 i A1
// Wszystkie sygnały po za A0 i A1 są zanegowane.

#define SET_MX_CLR PORT(MX_CLRPORT) |= (1<<MX_CLR)// stan wysoki na linii CLR
#define CLR_MX_CLR PORT(MX_CLRPORT) &= ~(1<<MX_CLR)// stan niski na linii CLR

#define SET_MX_UPD PORT(MX_UPDPORT)|= (1<<MX_UPD) // stan wysoki na linii UPD
#define CLR_MX_UPD PORT(MX_UPDPORT) &= ~(1<<MX_UPD)// stan niski na linii UPD

#define SET_MX_CS PORT(MX_CSPORT) |= (1<<MX_CS)// stan wysoki na linii CS
#define CLR_MX_CS PORT(MX_CSPORT) &= ~(1<<MX_CS)// stan niski na linii CS

#define SET_MX_WR PORT(MX_WRPORT) |= (1<<MX_WR)// stan wysoki na linii WR
#define CLR_MX_WR PORT(MX_WRPORT) &= ~(1<<MX_WR)// stan niski na linii WR

#define SET_MX_A0 PORT(MX_A0PORT) |= (1<<MX_A0)// stan wysoki na linii A0
#define CLR_MX_A0 PORT(MX_A0PORT) &= ~(1<<MX_A0)// stan niski na linii A0

#define SET_MX_A1 PORT(MX_A1PORT) |= (1<<MX_A1)// stan wysoki na linii A1
#define CLR_MX_A1 PORT(MX_A1PORT) &= ~(1<<MX_A1)// stan niski na linii A1

// Kasuj wszystkie rejest
static inline void clear_MXregister(void){
CLR_MX_CLR;
asm("nop");
asm("nop");
SET_MX_CLR;
}
//----------------------------------------------------------------------------------------
//Inicjacja MX7537
//Ustawienie wszystkich linii danych jako Wyjścia
//
//----------------------------------------------------------------------------------------

void MX_DAC_init(void)
{
DDR(MX_PORT)|= 0xFF; // Cały port dla danych
DDR(MX_CSPORT)|= (1<<MX_CS);
DDR(MX_WRPORT)|= (1<<MX_WR);
DDR(MX_UPDPORT) |= (1<<MX_UPD);
DDR(MX_CLRPORT) |= (1<<MX_CLR);
DDR(MX_A0PORT)|= (1<<MX_A0);
DDR(MX_A1PORT)|= (1<<MX_A1);
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;

}

void load_dac_A(uint16_t DAC_A_data){

// załaduj LSB
CLR_MX_A0;
CLR_MX_A1;
PORT(MX_PORT) = DAC_A_data;
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;

CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_WR;


// Załaduj MSB
PORT(MX_PORT) = DAC_A_data >> 8;
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
SET_MX_A0;
CLR_MX_A1;
CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_WR;

CLR_MX_A0;
update_MXregister();
}

void load_dac_B(uint16_t DAC_B_data){
// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;

CLR_MX_A0;
SET_MX_A1;
CLR_MX_WR;
PORT(MX_PORT) = DAC_B_data;
SET_MX_WR;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;

SET_MX_A0;
SET_MX_A1;
CLR_MX_WR;
PORT(MX_PORT) = DAC_B_data >> 8;
SET_MX_WR;
update_MXregister();
}


void update_MXregister(void){

SET_MX_CS;
SET_MX_CLR;
SET_MX_UPD;
SET_MX_WR;
//CLR_MX_CS; // testowo
CLR_MX_UPD;
CLR_MX_WR;

}


void test (void){
_delay_us(10);
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
SET_MX_A0;
SET_MX_A1;
PORT(MX_PORT) = 0xff;
_delay_us(10);
CLR_MX_A1;
CLR_MX_A0;
CLR_MX_WR;
CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_CLR;
PORT(MX_PORT) = 0x00;
}[/syntax]

Teraz tylko wyrzeźbić część analogową do poważniejszych testów i można poprawiać bibliotekę

Obrazek
Obrazek

Statystyki: Napisane przez Gość — 19 kwi 2013, o 11:30

]]> 2013-04-18T23:19:34+01:00 2013-04-18T23:19:34+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34684#p34684 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
mów co chcesz ;) ale idę o zakład, że najbezpieczniej (zresztą zawsze przy tego typu transmisji równoległej), pierwsze co zrobić to wystawić dane na szynę równoległą, z czasówki widać, że podobnie wcześniej MUSI być wystawiony adres, więc ja od tego bym zaczynał ....

potem zwróć uwagę na czasy t5 i t6 ;) 0ns

ważny jest t7 (WR) oraz t8 (CLR) ale w przypadku AVRka popędzanego byle wolnym 8MHz to żaden z tych czasów nie ma znaczenia - nie musisz się martwić i w jednym cyklu możesz banglować tymi sygnałami. Ewentualnie przy 16MHz i więcej można byłoby próbować wstawiać jakiegoś NOP'a w czasie t7 czy t8, ale podejrzewam że obejdzie się i bez NOP'a

zwróć uwagę, że w tego typu czasówkach masz podane tak w ogóle minimalne czasy ;) a nie WYMAGANE czasy bo tu często bywają nieporozumienia.

zatem wystarczy jak mówiłem wystawić DANE i ADRES czy tam ADRES i DANE (obojętna kolejność) a potem przebanglować CS,UPD, WR, CLR i co ważne na zakończenie ustawić wszystkie w stan WYSOKI.

Tak samo ustawić te linie w stan wysoki przy jakiejś inicjalizacji biblioteki po ustawieniu kierunków

a potem każdy zapis nie musi się już zaczynać od ustawiania tych linii w stan wysoki - bo tylko będziesz marnował Flash i swój czas tzn czas procka ;) ...

i będzie śmigać - tak myślę - no ale przetestuj i zobacz ;)

Statystyki: Napisane przez mirekk36 — 18 kwi 2013, o 23:19

]]> 2013-04-18T22:50:46+01:00 2013-04-18T22:50:46+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34682#p34682 <![CDATA[Re: Odp: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez PawelGaj — 18 kwi 2013, o 22:50

]]> 2013-04-18T13:30:21+01:00 2013-04-18T13:30:21+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34634#p34634 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> .........jeszcze walczę. Dzięki za zwrócenie uwagi.

Po przemyśleniach doszedłem do błędnego wniosku ;), bo dalej mi coś się nie podoba, ale już chyba wiem gdzie leży problem
chwilowo wygląda to tak
[syntax=c]/*
* MX7537.c
*
* Created on: 17-04-2013
* Author: Sylwester Taras
*/

#include <avr/io.h>
#include <stdlib.h>

#include "MX7537.h"
// makrodefinicje operacji na sygnałach sterujących CLR, UPD, WR, CS, A0 i A1
// Wszystkie sygnały po za A0 i A1 są zanegowane.

#define SET_MX_CLR PORT(MX_CLRPORT) |= (1<<MX_CLR)// stan wysoki na linii CLR
#define CLR_MX_CLR PORT(MX_CLRPORT) &= ~(1<<MX_CLR)// stan niski na linii CLR

#define SET_MX_UPD PORT(MX_UPDPORT)|= (1<<MX_UPD) // stan wysoki na linii UPD
#define CLR_MX_UPD PORT(MX_UPDPORT) &= ~(1<<MX_UPD)// stan niski na linii UPD

#define SET_MX_CS PORT(MX_CSPORT) |= (1<<MX_CS)// stan wysoki na linii CS
#define CLR_MX_CS PORT(MX_CSPORT) &= ~(1<<MX_CS)// stan niski na linii CS

#define SET_MX_WR PORT(MX_WRPORT) |= (1<<MX_WR)// stan wysoki na linii WR
#define CLR_MX_WR PORT(MX_WRPORT) &= ~(1<<MX_WR)// stan niski na linii WR

#define SET_MX_A0 PORT(MX_A0PORT) |= (1<<MX_A0)// stan wysoki na linii A0
#define CLR_MX_A0 PORT(MX_A0PORT) &= ~(1<<MX_A0)// stan niski na linii A0

#define SET_MX_A1 PORT(MX_A1PORT) |= (1<<MX_A1)// stan wysoki na linii A1
#define CLR_MX_A1 PORT(MX_A1PORT) &= ~(1<<MX_A1)// stan niski na linii A1

// Kasuj wszystkie rejest
static inline void clear_MXregister(void){
CLR_MX_CLR;
}
//----------------------------------------------------------------------------------------
//Inicjacja MX7537
//Ustawienie wszystkich linii danych jako Wyjścia
//
//----------------------------------------------------------------------------------------

void MX_DAC_init(void)
{
DDR(MX_PORT)|= 0xFF; // Cały port dla danych
DDR(MX_CSPORT)|= (1<<MX_CS);
DDR(MX_WRPORT)|= (1<<MX_WR);
DDR(MX_UPDPORT) |= (1<<MX_UPD);
DDR(MX_CLRPORT) |= (1<<MX_CLR);
DDR(MX_A0PORT)|= (1<<MX_A0);
DDR(MX_A1PORT)|= (1<<MX_A1);

PORT(MX_PORT)= 0x00;
CLR_MX_CLR;
CLR_MX_CS;
CLR_MX_UPD;
CLR_MX_WR;
CLR_MX_A0;
CLR_MX_A1;
clear_MXregister();
}

void load_dac_A(uint16_t DAC_A_data){

// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
CLR_MX_A0;
CLR_MX_A1;
CLR_MX_CS;
CLR_MX_UPD;
PORT(MX_PORT) = DAC_A_data;
CLR_MX_WR;
SET_MX_WR;
SET_MX_CLR;
SET_MX_UPD;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
SET_MX_A0;
CLR_MX_A1;
CLR_MX_CS;
CLR_MX_UPD;
PORT(MX_PORT) = DAC_A_data >> 8;
CLR_MX_WR;
SET_MX_WR;
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_A0;
update_MXregister();
}

void load_dac_B(uint16_t DAC_B_data){
// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;

CLR_MX_A0;
SET_MX_A1;
CLR_MX_WR;
PORT(MX_PORT) = DAC_B_data;
SET_MX_WR;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;

SET_MX_A0;
SET_MX_A1;
CLR_MX_WR;
PORT(MX_PORT) = DAC_B_data >> 8;
SET_MX_WR;
update_MXregister();
}


void update_MXregister(void){
SET_MX_CS;
SET_MX_CLR;
CLR_MX_UPD;
CLR_MX_WR;
}[/syntax]

Zdaje mi się, że powinienem jednak najpierw poustawiać bity, a potem je naraz wywalać na szynę..........

[syntax=c]void load_dac_A(uint16_t DAC_A_data){

// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
CLR_MX_A0;
CLR_MX_A1;
CLR_MX_CS;
CLR_MX_UPD;
PORT(MX_PORT) = DAC_A_data;
CLR_MX_WR;
SET_MX_WR;
SET_MX_CLR;
SET_MX_UPD;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
SET_MX_CS;
SET_MX_WR;
SET_MX_A0;
CLR_MX_A1;
CLR_MX_CS;
CLR_MX_UPD;
PORT(MX_PORT) = DAC_A_data >> 8;
CLR_MX_WR;
SET_MX_WR;
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_A0;
update_MXregister();
}[/syntax]

Obrazek
Obrazek

Zastanawiam się, czy nie powinienem zrobić jak w funkcji static inline void lcd_sendHalf(uint8_t data); ??? w bibliotekach Mirka.
Czy może chwilowo nie bawić się w uniwersalność biblioteki? może lecieć na pałę ;).

Statystyki: Napisane przez Gość — 18 kwi 2013, o 13:30

]]> 2013-04-18T13:24:21+01:00 2013-04-18T13:24:21+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34632#p34632 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
[syntax=c]// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;
CLR_MX_WR;
CLR_MX_A0;
CLR_MX_A1;
PORT(MX_PORT) = DAC_A_data;[/syntax]

nie mówię, że to źle - bo nie wiem - ale jak potwierdzisz - to będzie pewne że masz OK ;)

Statystyki: Napisane przez mirekk36 — 18 kwi 2013, o 13:24

]]> 2013-04-18T12:56:04+01:00 2013-04-18T12:56:04+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=34619#p34619 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
Wrzucam tu celem wysłuchania solidnej porcji krytyki ;) moją przymiarkę bibliotek do MX7537

[syntax=c]/*
* MX7537.c
*
* Created on: 17-04-2013
* Author: Sylwester Taras
*/

#include <avr/io.h>
#include <stdlib.h>

#include "MX7537.h"
// makrodefinicje operacji na sygnałach sterujących CLR, UPD, WR, CS, A0 i A1
// Wszystkie sygnały po za A0 i A1 są zanegowane.

#define SET_MX_CLR PORT(MX_CLRPORT) |= (1<<MX_CLR)// stan wysoki na linii CLR
#define CLR_MX_CLR PORT(MX_CLRPORT) &= ~(1<<MX_CLR)// stan niski na linii CLR

#define SET_MX_UPD PORT(MX_UPDPORT)|= (1<<MX_UPD) // stan wysoki na linii UPD
#define CLR_MX_UPD PORT(MX_UPDPORT) &= ~(1<<MX_UPD)// stan niski na linii UPD

#define SET_MX_CS PORT(MX_CSPORT) |= (1<<MX_CS)// stan wysoki na linii CS
#define CLR_MX_CS PORT(MX_CSPORT) &= ~(1<<MX_CS)// stan niski na linii CS

#define SET_MX_WR PORT(MX_WRPORT) |= (1<<MX_WR)// stan wysoki na linii WR
#define CLR_MX_WR PORT(MX_WRPORT) &= ~(1<<MX_WR)// stan niski na linii WR

#define SET_MX_A0 PORT(MX_A0PORT) |= (1<<MX_A0)// stan wysoki na linii A0
#define CLR_MX_A0 PORT(MX_A0PORT) &= ~(1<<MX_A0)// stan niski na linii A0

#define SET_MX_A1 PORT(MX_A1PORT) |= (1<<MX_A1)// stan wysoki na linii A1
#define CLR_MX_A1 PORT(MX_A1PORT) &= ~(1<<MX_A1)// stan niski na linii A1

//----------------------------------------------------------------------------------------
//
// Ustawienie wszystkich linii danych jako WYjścia
//
//----------------------------------------------------------------------------------------
void data_dir_out(void)
{
DDR(MX_PORT)|= 0xFF; // Cały port dla danych
DDR(MX_CSPORT)|= (1<<MX_CS);
DDR(MX_WRPORT)|= (1<<MX_WR);
DDR(MX_UPDPORT) |= (1<<MX_UPD);
DDR(MX_CLRPORT) |= (1<<MX_CLR);
DDR(MX_A0PORT)|= (1<<MX_A0);
DDR(MX_A1PORT)|= (1<<MX_A1);
}

void load_dac_A(uint16_t DAC_A_data){

// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;
CLR_MX_WR;
CLR_MX_A0;
CLR_MX_A1;
PORT(MX_PORT) = DAC_A_data;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;
CLR_MX_WR;
SET_MX_A0;
CLR_MX_A1;
PORT(MX_PORT) = DAC_A_data >> 8;
}

void load_dac_B(uint16_t DAC_B_data){
// załaduj LSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;
CLR_MX_WR;
CLR_MX_A0;
SET_MX_A1;
PORT(MX_PORT) = DAC_B_data;

// Załaduj MSB
SET_MX_CLR;
SET_MX_UPD;
CLR_MX_CS;
CLR_MX_WR;
SET_MX_A0;
SET_MX_A1;
PORT(MX_PORT) = DAC_B_data >> 8;
}
// Kasuj wszystkie rejest
void clear_MXregister(void){
CLR_MX_CLR;
}

void update_MXregister(void){
SET_MX_CS;
SET_MX_CLR;
CLR_MX_UPD;
CLR_MX_WR;
}[/syntax]

[syntax=c]/*
* MX7537.h
*
* Created on: 17-04-2013
* Author: Sylwester Taras
*/

#ifndef MX7537_H_
#define MX7537_H_

#include "../common.h"
//**************************
//Parametry pracy sterownika
//
//**************************
#define MX_CS7
#define MX_CSPORTC

#define MX_WR4
#define MX_WRPORTC
#define MX_UPD6
#define MX_UPDPORTC
#define MX_CLR5
#define MX_CLRPORTC
#define MX_A00
#define MX_A0PORTB
#define MX_A11
#define MX_A1PORTB

#define MX_PORTD

#define DB00
#define DB11
#define DB22
#define DB33
#define DB44
#define DB55
#define DB66
#define DB77


#endif /* MX7537_H_ */[/syntax]

Moje podstawowe pytanie, czy to zmierza w dobrym kierunku?

Wszelkie podobieństwa do bibliotek Mirka (hd44780) jak najbardziej zamierzone ;).

Statystyki: Napisane przez Gość — 18 kwi 2013, o 12:56

]]> 2012-09-18T21:52:10+01:00 2012-09-18T21:52:10+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15461#p15461 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

jeszcze kombinowałem żeby do tego użyć strukturę zamiast tablicy jak w twoim przypadku ;)

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 21:52

]]> 2012-09-18T21:45:09+01:00 2012-09-18T21:45:09+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15460#p15460 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

ale jak zrobisz tak:

union {
uint16_t data;
uint8_t tab[2];
} rozbicie;

to

MSB = .tab[0];
LSB = .tab[1];

to już będzie OK ;)

Statystyki: Napisane przez mirekk36 — 18 wrz 2012, o 21:45

]]> 2012-09-18T21:27:14+01:00 2012-09-18T21:27:14+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15454#p15454 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
[syntax=c]union bajty{
uint16_t data;
uint8_t MSB;
uint8_t LSB;
}rozbicie;

uint16_t data=0xFFFF;

rozbicie.data = data;[/syntax]

a dalej już się używa tak :

MSB = rozbicie.MSB
LSB = rozbicie.LSB

Mam rację :?: ;)

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 21:27

]]> 2012-09-18T20:59:43+01:00 2012-09-18T20:59:43+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15441#p15441 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 20:59

]]> 2012-09-18T20:50:19+01:00 2012-09-18T20:50:19+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15434#p15434 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 20:50

]]> 2012-09-18T20:29:54+01:00 2012-09-18T20:29:54+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15427#p15427 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 20:29

]]> 2012-09-18T19:29:42+01:00 2012-09-18T19:29:42+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15410#p15410 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
------------------------ [ Dodano po: 1 minucie ]

Nie działa :(

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 19:29

]]> 2012-09-18T17:27:13+01:00 2012-09-18T17:27:13+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15405#p15405 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> Statystyki: Napisane przez Gość — 18 wrz 2012, o 17:27

]]> 2012-09-18T16:32:01+01:00 2012-09-18T16:32:01+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15401#p15401 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> . I przy rozdzielczości 14bit dało by się to już osiągnąć. Biorąc po uwagę iż użyję przetworników o błędzie 0.5% oraz źródła napięciowego o dokładności 0.02% i 1ppm. Powinno to dać dosyć precyzyjne pomiary.

Z mierzeniem też nie powinno być problemu, bo mam gotowe rozwiązania na CS5532, ewentualnie ADS1216 itp. Co prawda nie od strony programowej a hardwaru, ale w przypadku tak precyzyjnych pomiarów software jest sprawą drugorzędną.

PS. AVR niestety ma bardzo duże szumy, przez co przy mniejszych wartościach są spore przekłamania, można co prawda uśredniać wynik itp. ale pewność pomiaru w funkcji czasu nadal pozostaje na poziomie pojedynczych procentów, a ja chcę zejść przynajmniej do wartości 0,5% albo mniej.

Statystyki: Napisane przez Gość — 18 wrz 2012, o 16:32

]]> 2012-09-18T16:22:48+01:00 2012-09-18T16:22:48+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15400#p15400 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> Statystyki: Napisane przez filipo96 — 18 wrz 2012, o 16:22

]]> 2012-09-18T15:03:42+01:00 2012-09-18T15:03:42+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15391#p15391 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Hehehe no wiesz wszystko zależy jakiej dokładności oczekujesz ........, swoją drogą dla uproszczenia konstrukcji też poszedłem tą samą drogą ;) ( wyszło masło maślane )

I nie dlatego że DAC na PWM jest jakiś beee ale dlatego że rodzi to mniejsze problemy według mnie ( co może być powiązane z brakiem odpowiedniej wiedzy ;) )

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 15:03

]]> 2012-09-18T14:38:14+01:00 2012-09-18T14:38:14+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15385#p15385 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>
Źródła napięcia odniesienia "załatwiłem" o dokładności 0.02% i 1ppm ;). Szkoda było by psuć parametry kiepskimi przetwornikami na PWM, czy nawet w ATXmegach. Są fajne procki z dobrymi DAC i ADC ale z jądrem 8051 wiec odpadają.

O DAC, cały czas o DAC.

W ADC, nie ma problemu bo mam 16-24bitowe przetworniki ADC po SPI, więc już w samej obsłudze SPI wrzucane będą dane do odpowiednich zmiennych (uint16 albo 32). Jedynie miałem problem z MX7537 bo one są równoległe i stąd potrzeba rozdzielenia 16bitowej danej na dwie 8bitowe.

Statystyki: Napisane przez Gość — 18 wrz 2012, o 14:38

]]> 2012-09-18T14:36:49+01:00 2012-09-18T14:36:49+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15384#p15384 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> rezasurmar napisał(a):

Kurcze ja to jednak ciemny jestem jak tabaka w rogu......


Co prawda chodziło mi o "w drugą stronę" czyli DAC, ale zasada zostaje ta sama :).

Nie odpowiada mi dokładność przetworników w AVR, za równo rozdzielczość mają za małą, jak i liniowość kiepską. Muszę się posiłkować zewnętrznymi.



Jakoś znowu pokrętnie piszesz :P

zdecyduj się czy gadamy o ADC czy jednak o DAC :P

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 14:36

]]> 2012-09-18T14:28:59+01:00 2012-09-18T14:28:59+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15383#p15383 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> Chyba można by to trochę poprawić dając zewn. napięcie odniesienia :?:

Statystyki: Napisane przez MirkoT — 18 wrz 2012, o 14:28

]]> 2012-09-18T14:23:08+01:00 2012-09-18T14:23:08+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15380#p15380 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Co prawda chodziło mi o "w drugą stronę" czyli DAC, ale zasada zostaje ta sama :).

Nie odpowiada mi dokładność przetworników w AVR, za równo rozdzielczość mają za małą, jak i liniowość kiepską. Muszę się posiłkować zewnętrznymi.

Statystyki: Napisane przez Gość — 18 wrz 2012, o 14:23

]]> 2012-09-18T13:59:51+01:00 2012-09-18T13:59:51+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15376#p15376 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez MirkoT — 18 wrz 2012, o 13:59

]]> 2012-09-18T13:53:52+01:00 2012-09-18T13:53:52+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15375#p15375 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]>

Statystyki: Napisane przez Malutki_27 — 18 wrz 2012, o 13:53

]]> 2012-09-18T13:50:07+01:00 2012-09-18T13:50:07+01:00 https://forum.atnel.pl/viewtopic.php?t=1555&p=15374#p15374 <![CDATA[Re: Dzielenie 14bit na 8+4 sterowanie DAC]]> Malutki_27 napisał(a):

;) tylko jakoś liczenie mi nie bardzo idzie ....... bo chyba ze trzy razy poprawiałem post.

no właśnie miałem napisać, że cosik mi nie pasi :lol: a tu już poprawiłeś

Statystyki: Napisane przez MirkoT — 18 wrz 2012, o 13:50

]]>