• R/O
  • SSH
  • HTTPS

pasripherals: Commit


Commit MetaInfo

Revision24 (tree)
Zeit2019-08-18 12:45:41
Autorderekwildstar

Log Message

- Resolvidos os problemas na unit UADS1115
- Substituídas todas as ocorrências de Bytes para UInt8 e PByte para PUint8, a fim de tornar as coisas mais bonitinhas :)
- Criados os parâmetros SwapBytes em funções de leitura e escrita de 16 bits
- Criadas versões protegidas das funções Write e Read
- Alterado o nome do método SelectRegister para SelectRegisterForReadOperation, a fim de deixar claro que esta função não deve ser usada em conjunção com operações de gravação de dados
- Documentação atualizada

Ändern Zusammenfassung

Diff

--- trunk/src/lib/UADS1115.pas (revision 23)
+++ trunk/src/lib/UADS1115.pas (revision 24)
@@ -11,7 +11,7 @@
1111 TADS1115GainAplifier = (agaTwoThirds,aga1,aga2,aga4,aga8,aga16);
1212 //: Esta enumeração representa as possíveis taxas de transferência de dados
1313 //: que o ADS1115 suporta
14- TADS1115DataRate = (adr8SPS,adr16SPS,adr32SPS,adr64SPS,adr128SPS,adr250SPS,adr475SPS,dr860SPS);
14+ TADS1115DataRate = (adr8SPS,adr16SPS,adr32SPS,adr64SPS,adr128SPS,adr250SPS,adr475SPS,adr860SPS);
1515
1616 TADS1115Mode = (amContinuous,amPowerDown);
1717 //: Esta enumeração representa registradores disponíves no ADS1115. Ao
@@ -40,25 +40,35 @@
4040 //: registrador será referenciado nas operações subsequentes. A tabela 6 do
4141 //: datasheet contém os valores possíveis (p. 18). Este método levanta
4242 //: exceções caso, por algum motivo, não seja possível escrever no
43- //: registrador POINTER
43+ //: registrador POINTER.
4444 //: @Param(ARegister Registrador que se quer selecionar)
4545 //: @SeeAlso(TADS1115Register)
46- procedure SelectRegister(ARegister: TADS1115Register);
47-
46+ procedure SelectRegisterForReadOperation(ARegister: TADS1115Register);
47+ //: Obtém o valor completo do registrador CONFIG, ou seja, todas as
48+ //: configurações
49+ //: @Returns(Valor do registrador CONFIG)
4850 function GetConfigRegister: UInt16;
51+ //: Configura o valor completo do registrador CONFIG
52+ //: @Param(AConfigurations Valor completo do registrador a ser gravado)
4953 procedure SetConfigRegister(AConfigurations: UInt16);
50- //function GetConfigField: UInt16;
51- //procedure SetConfigField(AFieldValue: UInt16);
54+ //: Obtém o valor de um dos componentes (campos) do registrador CONFIG
55+ //: @Param(AFieldIndex Índice do primeiro bit do campo a ser lido)
56+ //: @Param(ABitsCount Tamanho do campo a ler em bits)
57+ //: @Returns(Valor do campo solicitado)
58+ function GetConfigField(AFieldIndex: UInt8; ABitsCount: UInt8): UInt16;
59+ //: Configura o valor de um dos componentes (campos) do registrador CONFIG
60+ //: @Param(AFieldIndex Índice do primeiro bit do campo a ser escrito)
61+ //: @Param(ABitsCount Tamanho do campo a escrever em bits)
62+ //: @Param(AFieldValue Valor a ser escrito no campo)
63+ procedure SetConfigField(AFieldIndex: UInt8; ABitsCount: UInt8; AFieldValue: UInt16);
5264
53-
54-
5565 function GetGainAplifier: TADS1115GainAplifier;
5666 function GetDataRate: TADS1115DataRate;
5767 function GetMode: TADS1115Mode;
58- function GetAIn0: SmallInt;
59- function GetAIn1: SmallInt;
60- function GetAIn2: SmallInt;
61- function GetAIn3: SmallInt;
68+ //function GetAIn0: SmallInt;
69+ //function GetAIn1: SmallInt;
70+ //function GetAIn2: SmallInt;
71+ //function GetAIn3: SmallInt;
6272
6373 procedure SetGainAplifier(AGainAmplifier: TADS1115GainAplifier);
6474 procedure SetDataRate(ADataRate: TADS1115DataRate);
@@ -71,10 +81,10 @@
7181 property Mode: TADS1115Mode read GetMode write SetMode;
7282
7383 { -37768 até 32767}
74- property AIn0: SmallInt read GetAIn0;
75- property AIn1: SmallInt read GetAIn1;
76- property AIn2: SmallInt read GetAIn2;
77- property AIn3: SmallInt read GetAIn3;
84+ //property AIn0: SmallInt read GetAIn0;
85+ //property AIn1: SmallInt read GetAIn1;
86+ //property AIn2: SmallInt read GetAIn2;
87+ //property AIn3: SmallInt read GetAIn3;
7888 end;
7989
8090 EADS1115 = class(EPasRipherals);
@@ -99,7 +109,15 @@
99109 CONFIG_MUX = 12; CONFIG_MUX_SOZE = 3;
100110 CONFIG_OS = 15; CONFIG_OS_SIZE = 1;
101111
102-procedure TADS1115.SelectRegister(ARegister: TADS1115Register);
112+// É possível configurar o registrador POINTER sozinho, em uma operação de
113+// escrita exclusiva e, posteriormente, realizar a leitura do registrador que
114+// ele aponta. Não é necessário configurar este registrador antes de cada
115+// leitura. Nas operações de escrita, entretanto, é sempre necessário configurar
116+// o registrador POINTER, juntamente com os dados que serão escritos, portanto,
117+// a função abaixo não pode ser usada em operações de escrita com o intuito de
118+// selecionar o registrador onde se quer escrever. O nome dela foi pensado para
119+// lembrar que isso não pode ser feito
120+procedure TADS1115.SelectRegisterForReadOperation(ARegister: TADS1115Register);
103121 begin
104122 I2C[FI2CController,FSlaveAddress].Write8Bits(Byte(ARegister),'Erro ao selecionar o registrador "' + GetEnumName(TypeInfo(TADS1115Register),Ord(ARegister)));
105123 end;
@@ -107,28 +125,56 @@
107125 function TADS1115.GetConfigRegister: UInt16;
108126 begin
109127 // Seleciona o registrador de configurações
110- SelectRegister(arConfig);
128+ SelectRegisterForReadOperation(arConfig);
111129
112130 // Lê todo o registrador de configurações
113- I2C[FI2CController,FSlaveAddress].Read16Bits(Result,'Erro ao ler o registrador de configurações');
131+ I2C[FI2CController,FSlaveAddress].Read16Bits(Result,'Erro ao ler o registrador de configurações',True);
114132 end;
115133
116134 procedure TADS1115.SetConfigRegister(AConfigurations: UInt16);
135+var
136+ WBuffer: PByte;
117137 begin
118- // Seleciona o registrador de configurações
119- SelectRegister(arConfig);
138+ GetMem(WBuffer,3);
139+ try
140+ // Para modificar o registrador de configurações, são necessários 3 bytes
141+ WBuffer[0] := Byte(arConfig); // Aponta para o registrador CONFIG
142+ WBuffer[1] := Hi(AConfigurations); // Byte mais significante das configurações
143+ WBuffer[2] := Lo(AConfigurations); // Byte menos significante das configurações
120144
121- // Escreve todo o registrador de configurações
122- I2C[FI2CController,FSlaveAddress].Write16Bits(AConfigurations,'Erro ao escrever no registrador de configurações');
123- //I2C[FI2CController,FSlaveAddress].Write8Bits(Hi(AConfigurations),'Erro ao escrever no registrador de configurações');
124- //I2C[FI2CController,FSlaveAddress].Write8Bits(Lo(AConfigurations),'Erro ao escrever no registrador de configurações');
145+ // Envia o buffer com os dados, escrevendo-os no FIFO
146+ I2C[FI2CController,FSlaveAddress].Write(WBuffer,3,'Erro ao escrever no registrador de configurações');
147+ finally
148+ FreeMem(WBuffer);
149+ end;
125150 end;
126151
152+function TADS1115.GetConfigField(AFieldIndex: UInt8; ABitsCount: UInt8): UInt16;
153+begin
154+ Result := GetBitsValue(GetConfigRegister,AFieldIndex,ABitsCount);
155+end;
156+
157+procedure TADS1115.SetConfigField(AFieldIndex: UInt8; ABitsCount: UInt8; AFieldValue: UInt16);
158+var
159+ ConfigRegister: Uint16;
160+begin
161+ try
162+ // Obtenho todo o registrador CONFIG
163+ ConfigRegister := GetConfigRegister;
164+
165+ // Altera os bits necessários
166+ SetBitsValue(@ConfigRegister,AFieldValue,AFieldIndex,ABitsCount);
167+ finally
168+ // Grava o registrador, com o campo atualizado
169+ SetConfigRegister(ConfigRegister);
170+ end;
171+end;
172+
127173 function TADS1115.GetGainAplifier: TADS1115GainAplifier;
128174 var
129175 Value: Byte;
130176 begin
131- Value := GetBitsValue(GetConfigRegister,CONFIG_PGA,CONFIG_PGA_SIZE);
177+ Value := GetConfigField(CONFIG_PGA,CONFIG_PGA_SIZE);
132178
133179 // Os 3 últimos valores possíveis para estes bits (5, 6 e 7) correspondem ao
134180 // mesmo ganho, os outros são diferentes entre si e podem ser obtidos a partir
@@ -141,72 +187,51 @@
141187
142188 function TADS1115.GetDataRate: TADS1115DataRate;
143189 begin
144-
190+ Result := TADS1115DataRate(GetConfigField(CONFIG_DR,CONFIG_DR_SIZE));
145191 end;
146192
147193 function TADS1115.GetMode: TADS1115Mode;
148194 begin
149- Result := TADS1115Mode(GetBitsValue(GetConfigRegister,CONFIG_MODE,CONFIG_MODE_SIZE));
195+ Result := TADS1115Mode(GetConfigField(CONFIG_MODE,CONFIG_MODE_SIZE));
150196 end;
151197
152-function TADS1115.GetAIn0: SmallInt;
153-begin
154-{ Configure o mux para single end (100) antes de ler o valor
155-configure como single shot ou usema propriedade para configurar este modo e só
156-permitir a execução aqui se o modo for single shot
198+//function TADS1115.GetAIn0: SmallInt;
199+//begin
200+//{ Configure o mux para single end (100) antes de ler o valor
201+//configure como single shot ou usema propriedade para configurar este modo e só
202+//permitir a execução aqui se o modo for single shot
203+//
204+//crie uma propriedade chamada modo que pode ser single shot ou continuous. Verifique como funciona o modo continuo pra saber se se podera usar esta propriedade enquanto estre modo estiver ON}
205+//end;
157206
158-crie uma propriedade chamada modo que pode ser single shot ou continuous. Verifique como funciona o modo continuo pra saber se se podera usar esta propriedade enquanto estre modo estiver ON}
159-end;
207+//function TADS1115.GetAIn1: SmallInt;
208+//begin
209+//
210+//end;
160211
161-function TADS1115.GetAIn1: SmallInt;
162-begin
212+//function TADS1115.GetAIn2: SmallInt;
213+//begin
214+//
215+//end;
163216
164-end;
217+//function TADS1115.GetAIn3: SmallInt;
218+//begin
219+//
220+//end;
165221
166-function TADS1115.GetAIn2: SmallInt;
167-begin
168-
169-end;
170-
171-function TADS1115.GetAIn3: SmallInt;
172-begin
173-
174-end;
175-
176222 procedure TADS1115.SetGainAplifier(AGainAmplifier: TADS1115GainAplifier);
177-var
178- ConfigRegister: Uint16;
179223 begin
180- ConfigRegister := GetConfigRegister;
181- try
182- SetBitsValue(@ConfigRegister,Byte(AGainAmplifier),CONFIG_PGA,CONFIG_PGA_SIZE);
183- finally
184- SetConfigRegister(ConfigRegister);
185- end;
224+ SetConfigField(CONFIG_PGA,CONFIG_PGA_SIZE,Byte(AGainAmplifier));
186225 end;
187226
188227 procedure TADS1115.SetDataRate(ADataRate: TADS1115DataRate);
189-var
190- ConfigRegister: Uint16;
191228 begin
192- ConfigRegister := GetConfigRegister;
193- try
194- SetBitsValue(@ConfigRegister,Byte(ADataRate),CONFIG_DR,CONFIG_DR_SIZE);
195- finally
196- SetConfigRegister(ConfigRegister);
197- end;
229+ SetConfigField(CONFIG_DR,CONFIG_DR_SIZE,Byte(ADataRate));
198230 end;
199231
200232 procedure TADS1115.SetMode(AMode: TADS1115Mode);
201-var
202- ConfigRegister: Uint16;
203233 begin
204- ConfigRegister := GetConfigRegister;
205- try
206- SetBitsValue(@ConfigRegister,Byte(AMode),CONFIG_MODE,CONFIG_MODE_SIZE);
207- finally
208- SetConfigRegister(ConfigRegister);
209- end;
234+ SetConfigField(CONFIG_MODE,CONFIG_MODE_SIZE,Byte(AMode));
210235 end;
211236
212237 constructor TADS1115.Create(AI2CController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress);
--- trunk/src/lib/UPasRipherals.pas (revision 23)
+++ trunk/src/lib/UPasRipherals.pas (revision 24)
@@ -171,7 +171,7 @@
171171 //: mais rápido. Isso é uma propriedade que só funciona quando se divide um
172172 //: número por uma potência de 2. 32 = 2^5, por isso se usa shr 5. Para mais
173173 //: informações, leia: https://en.wikipedia.org/wiki/Division_by_two#Binary
174- function RegisterGroupIndex: Byte;
174+ function RegisterGroupIndex: UInt8;
175175 //: RegisterBitIndex é responsvel por selecionar um dos bits dentro de um
176176 //: registrador de 32 bits, portanto RegisterBitIndex retorna um valor de 0
177177 //: a 31 sempre. FGPIONumber and 31 é o mesmo que fazer FGPIONumber mod 32,
@@ -179,7 +179,7 @@
179179 //: quando se quer obter o módulo da divisão por um número que é potência de
180180 //: 2. 31 = 2^5 - 1 <=> 32 - 1 = 31, por isso se use FGPIONumber and 31.
181181 //: Para mais informações, leia: https://jacksondunstan.com/articles/1946
182- function RegisterBitIndex: Byte;
182+ function RegisterBitIndex: UInt8;
183183 //: RegisterBitValue é o valor que corresponde ao número binário formado
184184 //: pelo bit ligado na posição indicada em RegisterBitIndex, por exemplo, se
185185 //: FGPIONumber = 18, RegisterBitIndex = 18 e RegisterBitValue, em notação
@@ -496,13 +496,13 @@
496496 function GetDataLength: UInt16;
497497 function GetFIFOContainsData: Boolean;
498498 function GetFIFOCanAcceptData: Boolean;
499- function GetFIFO: Byte;
499+ function GetFIFO: UInt8;
500500 procedure SetEnabled(AEnabled: Boolean);
501501 procedure SetTransferDone(AResetTransferDoneStatus: Boolean);
502502 procedure SetNak(AResetNackStatus: Boolean);
503503 procedure SetTimeOut(AResetClockStretchStatus: Boolean);
504504 procedure SetDataLength(ADataLength: UInt16);
505- procedure SetFIFO(AValue: Byte);
505+ procedure SetFIFO(AValue: UInt8);
506506 public
507507 //: Limpa o campo DATA do registrador FIFO, escrevendo 1 no campo CLEAR do
508508 //: registrador C
@@ -535,7 +535,7 @@
535535 //: contém 1, significa que o FIFO contém <<pelo menos>> 1 byte". Ora, se o
536536 //: FIFO mencionado fosse o registrador, não faria sentido falar em "pelo
537537 //: menos", já que o campo DATA do registrador FIFO só comporta no máximo 1
538- //: Byte (8 bits). Logo, concluo que o campo DATA do registrador FIFO é uma
538+ //: UInt8 (8 bits). Logo, concluo que o campo DATA do registrador FIFO é uma
539539 //: "porta" através da qual eu consigo ler o (ou escrver no) FIFO "real",
540540 //: que tem 128 bits (16 Bytes)
541541 //: @Param(ABuffer Variável não inicializada que receberá os Bytes lidos a
@@ -546,39 +546,71 @@
546546 //: parâmetro ABuffer)
547547 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
548548 //: @Link(TPRI2CTransferResult))
549- function Read(out ABuffer: PByte; ABufferSize: UInt32): TPRI2CTransferResult; overload;
549+ function Read(out ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult; overload;
550550 //: Esta função lê 2 Bytes (16 bits) a partir do dispositivo escravo, lendo
551551 //: 2 bytes a partir do FIFO.
552- //:
553- //: Internamente a função troca a ordem dos bytes lidos a partir do FIFO
554- //: Isso é necessário por causa da incompatibilidade entre a represetação de
555- //: um PByte com dois bytes e um UInt16 (que tem dois bytes). Para entender
556- //: melhor, use como exemplo o valor padrão do registrador CONFIG do
557- //: ADS1115, que é 8583h. Na memória, o buffer lido é semelhante a um array
558- //: com dois bytes [85,83]. Como se pode ver, a posição dos bytes na memória
559- //: é na ordem correta de leitura, no entanto números são armazenados na
560- //: memória da direita para a esquerda, fazendo com que o cast direto a
561- //: partir dos dois bytes apontandos pelo buffer resultasse no número 8385h,
562- //: que é errado. Para resolver, usa-se a função @Code(Swap), que troca a
563- //: posição de dois bytes dentro de um UInt16, fazendo com que o resultado
564- //: fique correto.
565552 //: @Param(AValue Este parâmetro de saída recebe os dois bytes lidos)
553+ //: @Param(ASwapBytes Caso este parâmetro seja true, os Bytes em AValue são
554+ //: trocados de posição. Eventualmente isso é necessário por causa da
555+ //: incompatibilidade entre a represetação de um PByte com dois bytes e um
556+ //: UInt16 (que tem dois bytes). Para entender melhor, use como exemplo o
557+ //: valor padrão do registrador CONFIG do ADS1115, que é 8583h. Na memória,
558+ //: o buffer lido é semelhante a um array com dois bytes [85,83]. Como se
559+ //: pode ver, a posição dos bytes na memória é na ordem correta de leitura,
560+ //: no entanto números são armazenados na memória da direita para a
561+ //: esquerda, fazendo com que o cast direto a partir dos dois bytes
562+ //: apontandos pelo buffer resultasse no número 8385h, que é errado. Para
563+ //: resolver, usa-se a função @Code(Swap), que troca a posição de dois bytes
564+ //: dentro de um UInt16, fazendo com que o resultado fique correto. Alguns
565+ //: sites da internet dizem que isso é por causa do ENDIANESS, a ordem de
566+ //: representação de Bytes na memória, no entanto eu discordo disso porque a
567+ //: comunicação feita com um dispositivo I2C é uma transferência Byte a Byte
568+ //: por meio de um buffer FIFO (first-in, first-out) e isso, naturalmente,
569+ //: enviaria os dois bytes do exemplo na ordem em que eles são vistos no
570+ //: array, por exemplo, [85,83]. Imagine o envio desse array sempre feito na
571+ //: ordem de leitura natural (esquerda para a direita), sendo assim o
572+ //: primeiro byte a chegar no dispositivo escravo é 83 e em seguida 85. O
573+ //: mesmo ocorre quando o dispositivo escravo envia dados ao mestre.
574+ //: Portanto, acho que isso não é um problema clássico de endianess, é
575+ //: simplemente um efeito colataral da forma de envio dos bytes através de
576+ //: um buffer FIFO)
566577 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
567578 //: @Link(TPRI2CTransferResult))
568- function Read16Bits(out AValue: UInt16): TPRI2CTransferResult; overload;
579+ function Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult; overload;
569580 //: Esta função lê 2 Bytes (16 bits) a partir do dispositivo escravo, lendo
570581 //: 2 bytes a partir do FIFO de forma protegida. Ela levanta exceções em
571582 //: caso de erros. Após executar esta função, caso o fluxo de execução passe
572- //: dela, signitica que os Byte foram lidos com suceso
583+ //: dela, signitica que os Bytes foram lidos com suceso
573584 //: @Param(AValue Este parâmetro de saída recebe os dois bytes lidos)
574585 //: @Param(ABaseErrorMessage Mensagem de erro a ser apresentada de forma
575586 //: concatenada com o motivo do erro no formato @Code(ABaseErrorMessage:
576587 //: Motivo do erro))
588+ //: @Param(ASwapBytes Caso este parâmetro seja true, os Bytes em AValue são
589+ //: trocados de posição)
577590 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
578591 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
579592 //: da falha)
580593 //: @SeeAlso(TPRI2CTransferResult)
581- procedure Read16Bits(out AValue: UInt16; ABaseErrorMessage: String); overload;
594+ procedure Read16Bits(out AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean); overload;
595+ //: Esta função lê 1 Byte (8 bits) a partir do dispositivo escravo, lendo
596+ //: 1 byte a partir do FIFO.
597+ //: @Param(AValue Este parâmetro de saída recebe o Byte lido)
598+ //: @Returns(A função retorna um dos possíveis valores da enumeraçao
599+ //: @Link(TPRI2CTransferResult))
600+ function Read8Bits(out AValue: UInt8): TPRI2CTransferResult; overload;
601+ //: Esta função lê 1 Byte (8 bits) a partir do dispositivo escravo, lendo
602+ //: 1 byte a partir do FIFO de forma protegida. Ela levanta exceções em
603+ //: caso de erro. Após executar esta função, caso o fluxo de execução passe
604+ //: dela, signitica que o Byte foi lido com suceso
605+ //: @Param(AValue Este parâmetro de saída recebe o Byte lido)
606+ //: @Param(ABaseErrorMessage Mensagem de erro a ser apresentada de forma
607+ //: concatenada com o motivo do erro no formato @Code(ABaseErrorMessage:
608+ //: Motivo do erro))
609+ //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
610+ //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
611+ //: da falha)
612+ //: @SeeAlso(TPRI2CTransferResult)
613+ procedure Read8Bits(out AValue: UInt8; ABaseErrorMessage: String); overload;
582614 //: Escreve uma determinada quantidade de bytes no dispositivo escravo. Este
583615 //: método funciona escrevendo bytes no FIFO.
584616 //: @Param(ABuffer Memória que contém os bytes a serem escritos)
@@ -587,22 +619,36 @@
587619 //: será passada em ABuffer)
588620 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
589621 //: @Link(TPRI2CTransferResult))
590- function Write(const ABuffer: PByte; ABufferSize: UInt32): TPRI2CTransferResult;
622+ function Write(const ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult; overload;
623+ //: Escreve uma determinada quantidade de bytes no dispositivo escravo. Este
624+ //: método funciona escrevendo bytes no FIFO de forma protegida. Ela levanta
625+ //: exceções em caso de erros. Após executar esta função, caso o fluxo de
626+ //: execução passe dela, signitica que os Bytes foram escritos com suceso
627+ //: @Param(ABuffer Memória que contém os bytes a serem escritos)
628+ //: @Param(ABufferSize Quantidade de bytes a serem escritos. Normalmente
629+ //: este valor é o mesmo valor utilizado para inicializar a variável que
630+ //: será passada em ABuffer)
631+ //: @Param(ABaseErrorMessage Mensagem de erro a ser apresentada de forma
632+ //: concatenada com o motivo do erro no formato @Code(ABaseErrorMessage:
633+ //: Motivo do erro))
634+ //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
635+ //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
636+ //: da falha)
637+ //: @SeeAlso(TPRI2CTransferResult)
638+ procedure Write(const ABuffer: PUInt8; ABufferSize: UInt32; ABaseErrorMessage: String); overload;
591639 //: Esta função escreve 2 Bytes (16 bits) no dispositivo escravo, escrevendo
592- //: 2 Byte no FIFO. Internamente a função troca a ordem dos bytes informados
593- //: no parâmetro, pelo mesmo motivo explicado na ajuda do método
594- //: @Code(Read16Bits). @Bold(ATENÇÃO: NÃO UTILIZE ESTA FUNÇÃO PARA ESCREVER
640+ //: 2 Byte no FIFO. @Bold(ATENÇÃO: NÃO UTILIZE ESTA FUNÇÃO PARA ESCREVER
595641 //: VALORES DE 8 BITS. PARA ESSA FINALIDADE, USE UMA DAS FORMAS DA FUNÇÃO
596642 //: @Link(Write8Bits))
597643 //: @Param(AValue Valor (2 Bytes) a serem escritos)
644+ //: @Param(ASwapBytes Caso este parâmetro seja true, os Bytes em AValue são
645+ //: trocados de posição)
598646 //: @SeeAlso(Read16Bits)
599- function Write16Bits(AValue: UInt16): TPRI2CTransferResult; overload;
647+ function Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult; overload;
600648 //: Esta função escreve 2 Bytes (16 bits) no dispositivo escravo, escrevendo
601649 //: 2 Byte no FIFO de forma protegida. Ela levanta exceções em caso de
602650 //: erros. Após executar esta função, caso o fluxo de execução passe dela,
603- //: signitica que os Bytes foram escritos com suceso. Internamente a função
604- //: troca a ordem dos bytes informados no parâmetro, pelo mesmo motivo
605- //: explicado na ajuda do método @Code(Read16Bits). @Bold(ATENÇÃO: NÃO
651+ //: signitica que os Bytes foram escritos com suceso. @Bold(ATENÇÃO: NÃO
606652 //: UTILIZE ESTA FUNÇÃO PARA ESCREVER VALORES DE 8 BITS. PARA ESSA
607653 //: FINALIDADE, USE UMA DAS FORMAS DA FUNÇÃO @Link(Write8Bits))
608654 //: @Param(AValue Valor (2 Bytes) a serem escritos)
@@ -609,17 +655,19 @@
609655 //: @Param(ABaseErrorMessage Mensagem de erro a ser apresentada de forma
610656 //: concatenada com o motivo do erro no formato @Code(ABaseErrorMessage:
611657 //: Motivo do erro))
658+ //: @Param(ASwapBytes Caso este parâmetro seja true, os Bytes em AValue são
659+ //: trocados de posição)
612660 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
613661 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
614662 //: da falha)
615663 //: @SeeAlso(TPRI2CTransferResult)
616- procedure Write16Bits(AValue: UInt16; ABaseErrorMessage: String); overload;
664+ procedure Write16Bits(AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean); overload;
617665 //: Esta função escreve 1 Byte (8 bits) no dispositivo escravo, escrevendo
618666 //: 1 Byte no FIFO.
619667 //: @Param(AValue Valor a ser escrito)
620668 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
621669 //: @Link(TPRI2CTransferResult))
622- function Write8Bits(AValue: Byte): TPRI2CTransferResult; overload;
670+ function Write8Bits(AValue: UInt8): TPRI2CTransferResult; overload;
623671 //: Esta função escreve 1 Byte (8 bits) no dispositivo escravo, escrevendo
624672 //: 1 Byte no FIFO de forma protegida. Ela levanta exceções em caso de
625673 //: erros. Após executar esta função, caso o fluxo de execução passe dela,
@@ -632,7 +680,7 @@
632680 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
633681 //: da falha)
634682 //: @SeeAlso(TPRI2CTransferResult)
635- procedure Write8Bits(AValue: Byte; ABaseErrorMessage: String); overload;
683+ procedure Write8Bits(AValue: UInt8; ABaseErrorMessage: String); overload;
636684
637685 property TransferType: TPRI2CTransferType read GetTransferType;
638686 property TransferActive: Boolean read GetTransferActive;
@@ -643,7 +691,7 @@
643691 property Nak: Boolean read GetNak write SetNak;
644692 property TimeOut: Boolean read GetTimeOut write SetTimeOut;
645693 property DataLength: UInt16 read GetDataLength write SetDataLength;
646- property FIFO: Byte read GetFIFO write SetFIFO;
694+ property FIFO: UInt8 read GetFIFO write SetFIFO;
647695 end;
648696
649697 { TCustomPasRipherals }
@@ -707,7 +755,7 @@
707755 function BSC1BaseAddress: PUInt32;
708756
709757 //: Use esta função para obter uma máscara com as características indicadas
710- function GetBitsMask(ABitIndex: Byte; ABitsCount: Byte): UInt32;
758+ function GetBitsMask(ABitIndex: UInt8; ABitsCount: UInt8): UInt32;
711759
712760 procedure PeripheralsBaseAddressAndSize(out ABaseAdddress: UInt32; out ASize: UInt32);
713761
@@ -716,10 +764,10 @@
716764 protected
717765 //: Use esta função para retornar o valor de um conjunto de bits dentro de
718766 //: um registrador de até 32 bits de tamanho
719- function GetBitsValue(ARegister: UInt32; ABitIndex: Byte; ABitsCount: Byte = 1): UInt32;
767+ function GetBitsValue(ARegister: UInt32; ABitIndex: UInt8; ABitsCount: UInt8 = 1): UInt32;
720768 //: Use esta função para configurar o valor de um conjunto de bits dentro de
721769 //: um registrador de até 32 bits de tamanho
722- procedure SetBitsValue(ARegister: PUInt32; AValue: UInt32; ABitIndex: Byte; ABitsCount: Byte = 1);
770+ procedure SetBitsValue(ARegister: PUInt32; AValue: UInt32; ABitIndex: UInt8; ABitsCount: UInt8 = 1);
723771
724772 property Clock[AClockId: TPRClockId]: TPRClock read GetClock;
725773 property GPIO[AGPIONumber: TPRGPIONumber]: TPRGPIO read GetGPIO;
@@ -1026,7 +1074,7 @@
10261074 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_TXD,BSC_S_TXD_SIZE).ToBoolean;
10271075 end;
10281076
1029-function TPRI2C.GetFIFO: Byte;
1077+function TPRI2C.GetFIFO: UInt8;
10301078 begin
10311079 Result := FPasRipherals.GetBitsValue(RegisterFIFO^,BSC_FIFO_DATA,BSC_FIFO_DATA_SIZE);
10321080 end;
@@ -1056,7 +1104,7 @@
10561104 RegisterDLEN^ := ADataLength;
10571105 end;
10581106
1059-procedure TPRI2C.SetFIFO(AValue: Byte);
1107+procedure TPRI2C.SetFIFO(AValue: UInt8);
10601108 begin
10611109 RegisterFIFO^ := AValue;
10621110 end;
@@ -1076,7 +1124,7 @@
10761124 RegisterC^ := (1 shl BSC_C_I2CEN) or (1 shl BSC_C_ST) or (AClearFifo.ToInteger shl BSC_C_CLEAR) or Byte(ATransferType);
10771125 end;
10781126
1079-function TPRI2C.Read(out ABuffer: PByte; ABufferSize: UInt32): TPRI2CTransferResult;
1127+function TPRI2C.Read(out ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult;
10801128 var
10811129 RemainingBytes: UInt32;
10821130 begin
@@ -1136,9 +1184,9 @@
11361184 SetTransferDone(True);
11371185 end;
11381186
1139-function TPRI2C.Read16Bits(out AValue: UInt16): TPRI2CTransferResult;
1187+function TPRI2C.Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult;
11401188 var
1141- RB: PByte;
1189+ RB: PUInt8;
11421190 begin
11431191 // Lê 2 bytes (16 bits)
11441192 Result := Read(RB,2);
@@ -1145,15 +1193,18 @@
11451193
11461194 if Result = pritrSuccess then
11471195 try
1148- AValue := Swap(PUInt16(RB)^);
1196+ AValue := PUInt16(RB)^;
1197+
1198+ if ASwapBytes then
1199+ AValue := Swap(AValue);
11491200 finally
11501201 FreeMem(RB);
11511202 end;
11521203 end;
11531204
1154-procedure TPRI2C.Read16Bits(out AValue: UInt16; ABaseErrorMessage: String);
1205+procedure TPRI2C.Read16Bits(out AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
11551206 begin
1156- case Read16Bits(AValue) of
1207+ case Read16Bits(AValue,ASwapBytes) of
11571208 pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
11581209 pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
11591210 pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
@@ -1160,8 +1211,32 @@
11601211 end;
11611212 end;
11621213
1163-function TPRI2C.Write(const ABuffer: PByte; ABufferSize: UInt32): TPRI2CTransferResult;
1214+function TPRI2C.Read8Bits(out AValue: UInt8): TPRI2CTransferResult;
11641215 var
1216+ RB: PUInt8;
1217+begin
1218+ // Lê 1 byte (8 bits)
1219+ Result := Read(RB,1);
1220+
1221+ if Result = pritrSuccess then
1222+ try
1223+ AValue := PUInt8(RB)^;
1224+ finally
1225+ FreeMem(RB);
1226+ end;
1227+end;
1228+
1229+procedure TPRI2C.Read8Bits(out AValue: UInt8; ABaseErrorMessage: String);
1230+begin
1231+ case Read8Bits(AValue) of
1232+ pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1233+ pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1234+ pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1235+ end;
1236+end;
1237+
1238+function TPRI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult;
1239+var
11651240 RemainingBytes: UInt32;
11661241 begin
11671242 if not Assigned(ABuffer) then
@@ -1229,26 +1304,31 @@
12291304 SetTransferDone(True);
12301305 end;
12311306
1232-function TPRI2C.Write16Bits(AValue: UInt16): TPRI2CTransferResult;
1233-//var
1234-// WB: PByte;
1307+procedure TPRI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32; ABaseErrorMessage: String);
12351308 begin
1309+ case Write(ABuffer,ABufferSize) of
1310+ pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1311+ pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1312+ pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1313+ end;
1314+end;
1315+
1316+function TPRI2C.Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult;
1317+begin
12361318 if AValue <= High(Byte) then
12371319 raise Exception.Create('O valor do parâmetro precisa estar compreendido entre 256 e 65535');
12381320
1239- // Troca a posição dos bytes em AValue. Veja explicação detalhada no
1240- // método Read16Bits
1241- AValue := Swap(AValue);
1321+ // Troca a posição dos bytes em AValue.
1322+ if ASwapBytes then
1323+ AValue := Swap(AValue);
12421324
1243- //WB := @AValue;
1244-
12451325 // Escreve 2 Bytes (16 bits)
12461326 Result := Write(@AValue,2);
12471327 end;
12481328
1249-procedure TPRI2C.Write16Bits(AValue: UInt16; ABaseErrorMessage: String);
1329+procedure TPRI2C.Write16Bits(AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
12501330 begin
1251- case Write16Bits(AValue) of
1331+ case Write16Bits(AValue,ASwapBytes) of
12521332 pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
12531333 pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
12541334 pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
@@ -1255,13 +1335,13 @@
12551335 end;
12561336 end;
12571337
1258-function TPRI2C.Write8Bits(AValue: Byte): TPRI2CTransferResult;
1338+function TPRI2C.Write8Bits(AValue: UInt8): TPRI2CTransferResult;
12591339 begin
12601340 // Escreve 1 Byte (8 bits)
12611341 Result := Write(@AValue,1);
12621342 end;
12631343
1264-procedure TPRI2C.Write8Bits(AValue: Byte; ABaseErrorMessage: String);
1344+procedure TPRI2C.Write8Bits(AValue: UInt8; ABaseErrorMessage: String);
12651345 begin
12661346 case Write8Bits(AValue) of
12671347 pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
@@ -1657,7 +1737,7 @@
16571737
16581738 function TPRGPIO.GetMode: TPRGPIOMode;
16591739 var
1660- Shift: Byte;
1740+ Shift: UInt8;
16611741 begin
16621742 // O resto da divisão por 10 multiplicado por 3 é capaz de selecionar, dentro
16631743 // do registrador, os 3 bits de modo. A seleção é feita por meio de um shift
@@ -1690,12 +1770,12 @@
16901770 end;
16911771 end;
16921772
1693-function TPRGPIO.RegisterGroupIndex: Byte;
1773+function TPRGPIO.RegisterGroupIndex: UInt8;
16941774 begin
16951775 Result := FGPIONumber shr 5;
16961776 end;
16971777
1698-function TPRGPIO.RegisterBitIndex: Byte;
1778+function TPRGPIO.RegisterBitIndex: UInt8;
16991779 begin
17001780 Result := FGPIONumber and 31;
17011781 end;
@@ -1815,7 +1895,7 @@
18151895
18161896 procedure TPRGPIO.SetMode(AGPIOMode: TPRGPIOMode);
18171897 var
1818- Shift: Byte;
1898+ Shift: UInt8;
18191899 begin
18201900 Shift := (FGPIONumber mod 10) * 3;
18211901
@@ -1878,7 +1958,7 @@
18781958 Result := (GPIOBaseAddress + GPIO_GPFSEL + Byte(AModeBank))^;
18791959 end;
18801960
1881-//procedure TCustomPasRipherals.CalcClockPWMDivisor(APeriod: Byte; AResolution: UInt32; out ADivisorI: UInt16; out ADivisorF: UInt16);
1961+//procedure TCustomPasRipherals.CalcClockPWMDivisor(APeriod: UInt8; AResolution: UInt32; out ADivisorI: UInt16; out ADivisorF: UInt16);
18821962 //var
18831963 // MaximumRange: UInt32;
18841964 // Divider: Double;
@@ -1937,7 +2017,7 @@
19372017 //: (duty cycle))
19382018 //: @Param(ADutyCycleMax valor máximo em microssegundos do ciclo de trabalho
19392019 //: (duty cycle))
1940-//procedure TCustomPasRipherals.CalcServoParameters(APeriod: Byte; ADutyCycleMin: UInt16; ADutyCycleMax: UInt16; ADesiredRange: UInt32; out ADivisorI: UInt16; out ADivisorF: UInt16; out ADataMin: UInt32; out ADataMax: UInt32);
2020+//procedure TCustomPasRipherals.CalcServoParameters(APeriod: UInt8; ADutyCycleMin: UInt16; ADutyCycleMax: UInt16; ADesiredRange: UInt32; out ADivisorI: UInt16; out ADivisorF: UInt16; out ADataMin: UInt32; out ADataMax: UInt32);
19412021 //var
19422022 // MaximumRange: UInt32;
19432023 // Divider: Double;
@@ -2380,12 +2460,12 @@
23802460 Result := FPeripherals + BSC1_BASE_OFFSET;
23812461 end;
23822462
2383-function TCustomPasRipherals.GetBitsValue(ARegister: UInt32; ABitIndex: Byte; ABitsCount: Byte = 1): UInt32;
2463+function TCustomPasRipherals.GetBitsValue(ARegister: UInt32; ABitIndex: UInt8; ABitsCount: UInt8 = 1): UInt32;
23842464 begin
23852465 Result := ARegister and GetBitsMask(ABitIndex,ABitsCount) shr ABitIndex
23862466 end;
23872467
2388-procedure TCustomPasRipherals.SetBitsValue(ARegister: PUInt32; AValue: UInt32; ABitIndex: Byte; ABitsCount: Byte);
2468+procedure TCustomPasRipherals.SetBitsValue(ARegister: PUInt32; AValue: UInt32; ABitIndex: UInt8; ABitsCount: UInt8);
23892469 begin
23902470 // Abaixo, GetBitsValue só está sendo utilizado como forma "validar" AValue.
23912471 // Caso este valor tenha um valor em bits maior que a quantidade de bits
@@ -2418,7 +2498,7 @@
24182498 }
24192499 end;
24202500
2421-function TCustomPasRipherals.GetBitsMask(ABitIndex: Byte; ABitsCount: Byte): UInt32;
2501+function TCustomPasRipherals.GetBitsMask(ABitIndex: UInt8; ABitsCount: UInt8): UInt32;
24222502 begin
24232503 Result := Pred(1 shl ABitsCount) shl ABitIndex;
24242504 {
Show on old repository browser