ATNEL tech-forum

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T14:56:15+01:00

Nie potrzebnie sobie życie utrudniasz, ja bym zrobił to tak, podziel uint32_u na bufor 4x uint8_u:

[syntax=c]uint8_u ADC_buff[4];

inline void SleepMode(buffer[]){
buffer[3] |= (1<<7);
}

inline void StandbyMode(buffer[]){
buffer[3] &= ~(1<<7);
}

inline void PowerDownMode(buffer[]){
buffer[3] |= (1<<6);
}

//chcesz ustawić SleepMode
SleepMode(ADC_buff);[/syntax]

Dla takich prostych funkcji warto używać inline, kompilator zamiast wywoływać funkcję wstawi jej zawartość w miejscu wywołania.

Statystyki: Napisane przez PROTON — 6 cze 2013, o 14:56

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T14:31:02+01:00

No i kolejny raz wyszło jak to mało wiem, kombinowałem z wskaźnikami, ale za cholere mi to nie wychodziło.

Teraz tylko wymyślić jak odwrócić kolejność, bez używania dodatkowych tablic i zmiennych .

Banalne (mam nadzieje, że to nie przypadek, że działa )
[syntax=c]uint32_t temp = 0xFEDCBA98;
uint8_t *tmp = ((uint8_t*) &temp)+3; // zwiększamy adres o 3 bajty w górę
lcd_locate(0,1);

lcd_hex(*tmp--); // a teraz jedziemy w "dół" od MSB
lcd_hex(*tmp--);
lcd_hex(*tmp--);
lcd_hex(*tmp);[/syntax]

Statystyki: Napisane przez Gość — 6 cze 2013, o 14:31

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T14:24:29+01:00

rezasurmar napisał(a):

No ale przy wysyłaniu po SPI trzeba to jakoś rozbić.......

Uparłeś się na uint32_t zamiast zrobić to na buforze, da się, proszę:

[syntax=c]uint32_t temp = 0xFEDCBA98;
uint8_t *tmp = (uint8_t *) &temp;

uint8_t val1 = *tmp++;
uint8_t val2 = *tmp++;
uint8_t val3 = *tmp++;
uint8_t val4 = *tmp;[/syntax]

AVR jest little endian więc pod val1 masz 0x89, pod val2 masz 0xBA, itd...

Statystyki: Napisane przez PROTON — 6 cze 2013, o 14:24

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T13:44:24+01:00

No wszystko pięknie ładnie, ale po pierwsze ten kawałek kodu działa, zrobiłem go tylko jako przykład.

Chodzi mi o to, że rejestr CS5532 jest 32bitowy tj. jak niżej

No i idąc dalej tym tropem, mając delfiny wyprowadzone w ten sposób
[syntax=c]// Configuraton Register
#define PSS (1<<31)// Power Save Select - Sleep Mode (oscilator inactive)
#define _PSS ~(1<<31)// Standby Mode (oscilator active, allows quick power-up)

#define PWD (1<<30)// Power Down Mode - Activate the power save select mode
#define _PWD ~(1<<30)// Normal Mode

#define RS (1<<29)// Reset System
#define _RS ~(1<<29)// Normal Mode
#define ResetSystem CS5532ConfigReg |= RS // Activate a Reset cycle

#define RV (1<<28)// READ ONLY!!!! System Was RESET

#define IS (1<<27)// Input Short - All Signal input pairs for each chanel
// are disconnected and shorted internally
#define _IS (1<<27)// Normal Input

#define GB (1<26)// A0 output is modified to output common mode output voltage
// of the instrumentation amplifier (typ. 2.5V) the output latch
// select bit is ignored when the guard buffer is activated
#define _GB ~(1<<26)// Normal Operation of A0 as an output latch

#define VRS (1<<25)// Voltage Reference Select 1V <= Vref <= 2.5V
#define _VRS ~(1<<25)// 2.5V < Vref <= [(VA+) - (VA-)]

#define A0 (1<<24)// Output Latch Bits
#define A1 (1<<23)// The lach bits will be set to the logic state of these bits upon command
#define _A0 ~(1<<24)// word execution if the output latch select bit (OLS) is set. Note that these
#define _A1 ~(1<<23)// logic outputs are powered from VA+ and VA-

#define OLS (1<<22)// Output Latch Select - When Set uses the configuration Register as the source of A1 and A0
// When low uses the Configuration Register as the source of A1 and A0
#define OGS (1<<20)// Offset Gain Select - Calibration register used are based of the CS1-CS0 bits
// Of the referenced Setup
#define _OGS ~(1<<20)// Calibration register used are based on the OG1-OG0 bits
// of the referenced Setup

#define FRS (1<<19)// Filter Rate Select ON
// Scale all output word rates and their corresponding filter charecteristic by a factor of 5/6
#define FilterRateON CS5532ConfigReg |= FRS
// Use the default output word rates
#define FilterRateOFF CS5532ConfigReg &= ~FRS[/syntax]
Dzięki temu, że mam rejestr 32bitowy mogę ustawić kilka rzeczy na raz, bez większych problemów.......
No ale przy wysyłaniu po SPI trzeba to jakoś rozbić.......

Statystyki: Napisane przez Gość — 6 cze 2013, o 13:44

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T13:33:32+01:00

A po co robisz przesunięcia?

pracujesz na 8 bitowym rdzeniu, wykorzystaj to tak:
[syntax=c]//zamiast
//uint32_t temp = 0xFEDCBA98;
//zrób tak
uint8_t temp[4] = {0xFE, 0xDC, 0xBA, 0x98};
lcd_locate(0,1);
lcd_hex(tmp[0]);[/syntax]

uint16_t i uint32_t należy używać praktycznie tylko przy mnożeniu i dzieleniu dużych liczb

Statystyki: Napisane przez PROTON — 6 cze 2013, o 13:33

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T13:12:33+01:00

No chodzi mi o to, że (przynajmniej dla mnie) sytacja w obu w/w przypadkach taka sama
tj. czy w pierwszym kodzie robimy przesunięcie
[syntax=c]uint32_t temp = 0xFEDCBA98;
uint8_t tmp = temp>>24;
lcd_locate(0,1);
lcd_hex(tmp);[/syntax]

czy w drugim
[syntax=c]uint8_t temp; // tu zrobiłem błąd wczesniej, bo ma być uint8_t
temp = CS5532ConfigReg >> 24;
SendSpi(temp);[/syntax]

No a kompilator twierdzi co innego, no i w drugim przypadku wysyłane są tylko zera......mimo, że 29 bit jest ustawiony........

Statystyki: Napisane przez Gość — 6 cze 2013, o 13:12

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T13:06:36+01:00

rezasurmar napisał(a):

No przecież w przykładowym kodzie, nie trzeba robić żadnych rzutowań, promocji do typu itp

A możesz tę myśl , swój pomysł rozwinąć ? bo ja kompletnie nie wiem o co chodzi ? tzn nigdy o tym nie słyszałem, że w jakichś tam przypadkach można robić rzutowania a w innych nie .... Skąd kompilator ma wiedzieć czy to kod przykładowy czy nie przykładowy ? .... no chyba że coś źle zrozumiałem dlatego proszę o doprecyzowanie

Statystyki: Napisane przez mirekk36 — 6 cze 2013, o 13:06

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-06T13:13:21+01:00

Problemów ciąg dalszy, bo teraz w drugą stronę czyli rozbijamy 32bity na 4x8bit

Tu tylko przykładowy kod by sprawdzić czy da się rozbić 32bitową "liczbę" na 4x 8bit wszystko ładnie działa nic się nie rzuca
[syntax=c]uint32_t temp = 0xFEDCBA98;
uint8_t tmp = temp>>24;
lcd_locate(0,1);
lcd_hex(tmp);
tmp = temp>>16;
lcd_locate(0,8);
lcd_hex(tmp);
tmp = temp>>8;
lcd_locate(1,0);
lcd_hex(tmp);
tmp = temp;
lcd_locate(1,8);
lcd_hex(tmp);[/syntax]

No a w programie
gdzie CS5532.c
[syntax=c]uint32_t CS5532ConfigReg = 0;
//........
void ResetCS5532(void){
ResetSystem;
WriteConfRegCS5532(CS5532ConfigReg);
//........wiem strasznie kocia ta funkcja poniżej, ale dzięki temu mam jasną sytuację
// co się dzieje w kodzie oraz co dokładnie jest wysyłane po SPI
// (potem będę modyfikować, chociaż jeszcze nie wiem jak ;))

void WriteConfRegCS5532(uint32_t CS5532ConfigReg){ // Zapisz do Configuration Register
uint8_t temp; // ma być uint8_t
temp = CS5532ConfigReg >> 24;
SendSpi(temp);
temp = CS5532ConfigReg >> 16;
SendSpi(temp);
temp = CS5532ConfigReg >> 8;
SendSpi(temp);
temp = CS5532ConfigReg;
SendSpi(temp);
}

}[/syntax]
[syntax=c]#define RS (1<<29)// Reset System
#define _RS ~(1<<29)// Normal Mode
#define ResetSystem CS5532ConfigReg |= RS // Activate a Reset cycle[/syntax]

Od razu wywala warnig DescriptionResourcePathLocationType
left shift count >= width of type [enabled by default]CS5532.c/ADC_CS5532/CS5532line 105C/C++ Problem
No przecież w przykładowym kodzie, nie trzeba robić żadnych rzutowań, promocji do typu itp.
kompilator mnie chyba nie lubi .

Rejestr konfiguracji jest 32bitowy w CS5532 i najwygodniej było by się do niego odwoływać przez 32bitową zmienną,a nie
bawić sie w jakies tablice, po prostymi definami możemy sobie wszystkie potrzebne setupy załatwić i potem tylko
wpisywać za jednym razem do zmiennej 32bitowej............kurcze trzeba było jednak zostać przy analogówce i lampach .

link do PDFa, Configuration Register jest na 26stronie opisany, jak by się komuś chciało zajrzeć.
https://docs.google.com/file/d/0B85u4HQ ... sp=sharing

Statystyki: Napisane przez Gość — 6 cze 2013, o 12:56

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T14:08:04+01:00

Dokładnie bo to jest naturalna droga ... odczyt bajtu, a jak więcej to do bufora ...

Statystyki: Napisane przez mirekk36 — 4 cze 2013, o 14:08

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T13:16:01+01:00

Można tak:
[syntax=c]void ReadBufferSpi(uint8_t len, uint8_t *buff){
PORTB &= ~(1< /* Wait for reception complete */
while (len--)){
while(!(SPSR & (1< /* Return data register */
*buff++ = SPDR;
}
PORTB |= (1< }

//używamy tego tak:
uint8_t data[3];
ReadBufferSpi(sizeof(data),data);[/syntax]

Statystyki: Napisane przez PROTON — 4 cze 2013, o 13:16

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T13:06:36+01:00

No to zobacz powołałeś tablicę jako zmienną lokalną, owszem po wyjściu z funkcji zanim coś się nie stanie na stosie to jeszcze dane w niej będą aktualne ale jak tylko coś (np kolejna funkcja) dobierze się do stosu to masz już pozamiatane ... więc albo tablica static albo globalna. A sposób rzeczywiście banalnie prosty wymyśliłeś jak widzisz

Statystyki: Napisane przez mirekk36 — 4 cze 2013, o 13:06

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T12:56:35+01:00

mirekk36 napisał(a):

rezasurmar napisał(a):

Tylko, nie wiem, jak się zachowa CS5532, gdy będę 4razy zmieniał linie CS/ hmmm

to wtedy wystarczy wyjąć z funkcji do odbioru pojedynczego bajtu banglowanie CS'em i dać to wyżej ok? gdyby było coś nie tak

Odpowiedziałem bez zastanowienia , przecież można zrobić for między sterowaniem CS/

Teraz walczę z wskaźnikiem do tablicy

[syntax=c]uint8_t* ReadDWordSpi(void){
uint8_t DwordADC[4];
uint8_t* wsk = DwordADC;

PORTB &= ~(1</* Wait for reception complete */
for(uint8_t i=0; i>4; i++){
while(!(SPSR & (1</* Return data register */
DwordADC[i] = SPDR;
}
PORTB |= (1<return wsk;
}[/syntax]

Statystyki: Napisane przez Gość — 4 cze 2013, o 12:56

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T12:36:39+01:00

rezasurmar napisał(a):

Tylko, nie wiem, jak się zachowa CS5532, gdy będę 4razy zmieniał linie CS/ hmmm

to wtedy wystarczy wyjąć z funkcji do odbioru pojedynczego bajtu banglowanie CS'em i dać to wyżej ok? gdyby było coś nie tak

Statystyki: Napisane przez mirekk36 — 4 cze 2013, o 12:36

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T12:22:29+01:00

No tak coś mi się nie podobało, tj. wiedziałem że gdzieś dzwoni, ale nie wiedziałem gdzie .

Tylko, nie wiem, jak się zachowa CS5532, gdy będę 4razy zmieniał linie CS/ hmmm. Zrobię testy i przekażę co i jak.

Dzięki Mirku.

Statystyki: Napisane przez Gość — 4 cze 2013, o 12:22

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T12:19:21+01:00

Panowie ale ja już niejednokrotnie pisałem na tym forum, że to całkowicie KARKOŁOMNA i wręcz wypaczona droga aby programując w C na 8 bitowcu, i chcąc odebrać coś czy wysłać w postaci kilku czy więcej bajtów zaczynać od "rozbebeszania" że tak powiem podstawowych funkcji do wysyłania pojedynczego bajtu ... no kilka dni temu był iście podobny temat tyle że tam kolega pytał o przesyłanie 4 czy 8 bajtów za pomocą kodowania Manchester ... i zaczął podobnie ....

tzn owszem dałoby radę to zrobić ale .... ale nie tędy droga w C

GIGANTYCZNĄ ZALETĄ w C jest to - że jak piszesz obsługę CZEGOKOLWIEK jakieś transmisji itp ... to zakoduj sobie w pamięci że ZAWSZE ale to ZAWSZE - PIERWSZY KROK to napisanie funkcji do odbierającej czy wysyłającej najmniejszy fragment zjadliwy dla twojego procka. Czyli np w 8-bitowcu będziesz pisał funkcję do wysyłania/odbierania pojedynczego bajtu, w 16-bitowym procku funkcję do transferu słowa a w ARM ? często do transferu podwójnego słowa

A co później - a później to już ZAWSZE tak samo - gdy masz najmniejszy klocuszek LEGO to składasz z niego większą funkcję, po prostu wywołując w przypadku 8-bitowca 4-krotnie ten najmniejszy klocek

to tyle odnośnie idei

a teraz - oczywiście że przesunięcia są tu tak samo dobre jak unie - tyle że trzeba jedno i drugie dobrze zakodować. Tzn ta twoja funkcja

ReadDWordSpi()

nie działa z prostego powodu .... o czym za chwilę - ale pomyśl sobie - gdybyś miał za chwilę z jakiegoś innego układu po SPI odebrać nie 4 a 8 bajtów to co ? pisałbyś funkcję do odbioru zmiennej 64-bitowej ? ... ok a jeśli miałbyś odebrać 12 bajtów to co? ... to QUNIEC tak ? nie ma większych zmiennych ... ?

dlatego podpowiem ci co robisz źle w tej swojej funkcji ale na prawdę uwierz mi - przerób ją tak żeby 4 razy wywołać funkcję odbioru jednego bajtu - pomyśl - przecież już przez to zaoszczędzisz niepotrzebnemu traceniu pamięci FLASH ok ???

a teraz dlaczego masz kłopot z przesunięciami - tak na szybko i na oko - bo pewnie znowu (piszę znowu bo już chyba kiedyś też miałeś z tym problem - ale zwróciłem ci uwagę i poradziłeś sobie a teraz pewnie zapomniałeś ) ... otóż zapomniałeś o tym:

http://atnel.pl/domyslna-promocja-do-typu-int.html

a u ciebie - hmm sam się przyjrzyj pod tym kątem tej linijce w swojej funkcji:

DwordADC = SPDR << 24;

i myślę że od razu dostrzeżesz co w niej się złego dzieje ale jak nie to pytaj śmiało dalej

Statystyki: Napisane przez mirekk36 — 4 cze 2013, o 12:19

Re: Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T11:56:55+01:00

Uważam że przesunięcia o wielokrotność 8 nie mają sensu, lepiej jest podać adres większy o 1.

lub użyć uni

UWAGA: Nie tesotwałem tego na AVR !!!

[syntax=c]union bufor{
uint32_t z32bit;
uint8_t z8bit[4];
};

// używamy tego tak:
bufor.z32bit = ;
uint8_t a = bufor.z8bit[0];
uint8_t b = bufor.z8bit[1];
uint8_t c = bufor.z8bit[2];
uint8_t d = bufor.z8bit[3];[/syntax]

UWAGA: Nie tesotwałem tego na AVR !!!

Statystyki: Napisane przez PROTON — 4 cze 2013, o 11:56

Składanie liczby 32bitowej z 4 liczb 8bitowych

2013-06-04T11:27:07+01:00

Witam i jak zwykle mam dziwny problem

Mam ci ja przetwornik CS5532, który po dostarczeniu do niego 8bitowego rozkazu, wysyła 32bitową zmienną po SPI, abstrahując że SPI w AVR jest 8bitowe, próbuję jakoś złożyć tą daną do jednej 32bitowej (lub 24bitowej, bo 24bity ma sama wartość ADC, reszta to bity kontrolne)

[syntax=c]uint32_t ReadDWordSpi(void){
uint32_t DwordADC = 0;
PORTB &= ~(1</* Wait for reception complete */
while(!(SPSR & (1</* Return data register */
DwordADC = SPDR << 24;
while(!(SPSR & (1</* Return data register */
DwordADC = SPDR << 16;
while(!(SPSR & (1</* Return data register */
DwordADC = SPDR << 8;
while(!(SPSR & (1</* Return data register */
DwordADC = SPDR;
}[/syntax]

Niestety z racji tego że następuje rzutowanie typów bo SPDR jest 8bitowy, nic co ponad 16bit nie chce mi działać .

Tu przykład jak testuje czy mi działa to składanie 8bitowych na 32bit

[syntax=c]uint32_t t2 = 0x12, t3 = 0x34, t4 = 0x56, t5 = 0x76;
uint32_t temp, temp1;
temp = ( (t2<<24) | (t3<<16) | (t4<<8) | (t5) );
lcd_locate(1,4);
lcd_hex(temp1 = temp >> 16);
lcd_locate(1,8);
lcd_hex(temp);[/syntax]
Niestety biblioteki LCD nie są przewidziane na tak duże liczby (łykają tylko max 16bit , stąd te dziwne złożenie).

W przykładowym kodzie obsługi CS5532 wykorzystywane jest tylko 16bitów (przynajmniej tak wynika z analizy) kod jest pisany co najmniej dziwnie, bo i komentarze są po ichniemu .
[syntax=c]#include
#include
/*CS5532ĎŕąŘ¶¨Ňĺ*/
#define cs5532_clk_h (PORTB|=(1<#define cs5532_clk_l (PORTB&=~(1<#define cs5532_cs_h (PORTB|=(1<#define cs5532_cs_l (PORTB&=~(1<#define cs5532_in_h (PORTB|=(1<#define cs5532_in_l (PORTB&=~(1<#define cs5532_out (PINB&0x08)

void cs5532_write(unsigned char write_cs5532data);
unsigned char cs5532_read(void);
void cs5532_start(void);
void cs5532_clear_over(void);
unsigned char cs5532_check_over(void);
void cs5532_start_one(void);
void cs5532_start_two(void);
unsigned int cs5532_read_ad(void);
void cs5532_format(unsigned char chanel_one,unsigned char chanel_two);
extern void delay(unsigned char d_ln);
unsigned int cs5532_read_ad(void)
{
unsigned int return_data;
unsigned char temp_data;
cs5532_clear_over();
return_data=cs5532_read();
return_data<<=8;
return_data+=cs5532_read();
temp_data=cs5532_read();
temp_data=cs5532_read();
return (return_data);
}
void cs5532_write(unsigned char write_cs5532data)
{
cs5532_cs_l;
/*asm("nop");
asm("nop");
asm("nop");*/
SPDR=write_cs5532data;
while(!(SPSR & (1< /*asm("nop");
asm("nop");*/
cs5532_cs_h;
}
unsigned char cs5532_read(void)
{
cs5532_cs_l;
/*asm("nop");
asm("nop");
asm("nop");*/
SPDR=0xFF;
while(!(SPSR & (1<return SPDR;
/*asm("nop");
asm("nop");*/
SPSR=0x00;
cs5532_cs_h;
}
void cs5532_start(void)
{
unsigned char i,j;
unsigned char write_data;
write_data=0xFF;
for(i=0;i<15;i++)
{
cs5532_write(write_data);
}
write_data=0xFE;
cs5532_write(write_data);
}

void cs5532_clear_over(void)
{
cs5532_write(0x00);
}
unsigned char cs5532_check_over(void)
{
unsigned char return_data;
cs5532_cs_h;
asm("nop");
cs5532_clk_l;
asm("nop");
asm("nop");
cs5532_cs_l;
asm("nop");
asm("nop");
asm("nop");
return_data=cs5532_out;
return_data>>=3;
cs5532_cs_h;
return (return_data);
}

void cs5532_start_one(void)
{
unsigned char write_data;
write_data=0x80;
cs5532_write(write_data);
}

void cs5532_start_two(void)
{
unsigned char write_data;
write_data=0x88;
cs5532_write(write_data);
}

void cs5532_format(unsigned char chanel_one,unsigned char chanel_two)
{
unsigned char i;
unsigned char write_data;
unsigned char read_data;
unsigned char cs5532_rst;
write_data=0x03; /*Đ´ĹäÖĂĽÄ´ćĆ÷*/
cs5532_write(write_data);
write_data=0x20; /*Ľ¤»îŇ»¸ö¸´Î»ÖÜĆÚ*/
cs5532_write(write_data);
for(i=0;i<3;i++)
{
write_data=0x00;
cs5532_write(write_data);
}
write_data=0x0B; /*¶ÁĹäÖĂĽÄ´ćĆ÷*/
cs5532_write(write_data);
read_data=cs5532_read();
cs5532_rst=read_data;
read_data=cs5532_read();
read_data=cs5532_read();
read_data=cs5532_read();
while(cs5532_rst & 0x10)
{
write_data=0x0B; /*¶ÁĹäÖĂĽÄ´ćĆ÷*/
cs5532_write(write_data);
read_data=cs5532_read();
cs5532_rst=read_data;
read_data=cs5532_read();
read_data=cs5532_read();
read_data=cs5532_read();
}
write_data=0x03; /*Đ´ĹäÖĂĽÄ´ćĆ÷*/
cs5532_write(write_data);
for(i=0;i<4;i++)
{
write_data=0x00; /*˛ÎżĽµçŃąÎŞ5·üŁ¬ČçÎŞ2.5·üÔň02H*/
cs5532_write(write_data);
}
write_data=0x05; /*ÉčÖĂÍ¨µŔÉčÖĂĽÄ´ćĆ÷*/
cs5532_write(write_data);
cs5532_rst=chanel_one&0x0f;
cs5532_rst<<=4;
chanel_one>>=4;
chanel_one+=cs5532_rst;
chanel_one>>=1;
chanel_one|=0x05; /*×ÖËŮÂĘ¸ßÎ»*/
write_data=chanel_one;
cs5532_write(write_data);
write_data=0x40; /*×ÖËŮÂĘµÍÎ»şÍÎďŔíÍ¨µŔ0*/
cs5532_write(write_data);
cs5532_rst=chanel_two&0x0f;
cs5532_rst<<=4;
chanel_two>>=4;
chanel_two+=cs5532_rst;
chanel_two>>=1;
chanel_two|=0x45; /*×ÖËŮÂĘ¸ßÎ»*/
write_data=chanel_two;
cs5532_write(write_data);
write_data=0x41; /*×ÖËŮÂĘµÍÎ»şÍÎďŔíÍ¨µŔ1*/
cs5532_write(write_data);
cs5532_start_one();
}[/syntax]

Statystyki: Napisane przez Gość — 4 cze 2013, o 11:27