• R/O
  • SSH
  • HTTPS

pasripherals: Commit


Commit MetaInfo

Revision29 (tree)
Time2019-09-03 11:14:13
Authorderekwildstar

Log Message

- amPowerDown agora é amSingleShot
- TADS1115GainAmplifier agora é TADS1115ProgramableGainAplifier
- Incluída a enumeração "TADS1115ComparatorMode"
- Incluída a enumeração "TADS1115InputMultiplexer"
- Criada a propriedade Working
- FRegisterSelected agora é FSelectedRegister
- Criada a função GetConversionRegister
- Criada a função AssembleConfigRegister
- Criada a função sobrecarregada "ConversionValue"
- Documentação atualizada
- MicroSleep agora é protected
- Removida a condição que limitava o uso de Write16Bits

Change Summary

Incremental Difference

--- trunk/src/lib/UADS1115.pas (revision 28)
+++ trunk/src/lib/UADS1115.pas (revision 29)
@@ -1,19 +1,21 @@
11 unit UADS1115;
22 {:< Esta unit contém todas as entidades necessárias que permitem o acesso
33 simplificado ao ADS1115}
4-{$mode objfpc}{$H+}interface
4+{$mode objfpc}{$H+}
55
6+interface
7+
68 uses
7- UPasRipherals;
9+ SysUtils, UPasRipherals;
810
911 type
1012 //: Esta enumeração representa os possíveis ganhos programáveis do ADS1115
11- TADS1115GainAplifier = (agaTwoThirds,aga1,aga2,aga4,aga8,aga16);
13+ TADS1115ProgramableGainAplifier = (apgaTwoThirds,apga1,apga2,apga4,apga8,apga16);
1214 //: Esta enumeração representa as possíveis taxas de transferência de dados
1315 //: que o ADS1115 suporta
1416 TADS1115DataRate = (adr8SPS,adr16SPS,adr32SPS,adr64SPS,adr128SPS,adr250SPS,adr475SPS,adr860SPS);
1517
16- TADS1115Mode = (amContinuous,amPowerDown);
18+ TADS1115Mode = (amContinuous,amSingleShot);
1719 //: Esta enumeração representa registradores disponíves no ADS1115. Ao
1820 //: escrever o valor ordinal de um dos elementos desta enumeração no
1921 //: registrador POINTER, é feita a seleção do registrador correspondente, o
@@ -26,7 +28,8 @@
2628 //: se quer saber qual registrador está selecionado. Como não é possível ler o
2729 //: registrador POINTER, a biblioteca mantém um campo interno para isso e este
2830 //: é o valor inicial, o qual será alterado para o valor correto, tão logo a
29- //: primeira leitura de registradores for realizada)
31+ //: primeira seleção de registrador seja realizada)
32+ //: @SeeAlso(SelectRegister)
3033 TADS1115Register = (arConversion,arConfig,arLoThresh,arHiThresh,arUnknown);
3134
3235 //: Esta enumeração representa os possíveis valores disponíveis para o campo
@@ -61,6 +64,35 @@
6164 //: para maiores informações de como usar este campo e para que ele serve
6265 TADS1115ComparatorPolarity = (acpActiveLow,acpActiveHigh);
6366
67+ //: Esta enumeração representa os possíveis valores disponíveis para o campo
68+ //: COMP_MODE do registrador CONFIG. Consulte as páginas 15 e 19 do DataSheet
69+ //: para maiores informações de como usar este campo e para que ele serve
70+ TADS1115ComparatorMode = (acmTraditional,acmWindow);
71+
72+ //: Esta enumeração representa os possíveis valores disponíveis para o campo
73+ //: MUX do registrador CONFIG. Este campo permite definir etre quais pinos do
74+ //: ADS1115 está sendo realizada a leitura de algum dispositivo analógico.
75+ //: Existem 4 configurações diferenciais e 4 configurações exclusivas. Abaixo,
76+ //: (P) é o polo positivo da entrada e (N) é o polo negativo
77+ //: @Value(aimAIN0_AIN1 Habilita a leitura diferencial de dados entre as
78+ //: entradas analógicas AIN0 (P) e AIN1 (N))
79+ //: @Value(aimAIN0_AIN3 Habilita a leitura diferencial de dados entre as
80+ //: entradas analógicas AIN0 (P) e AIN3 (N))
81+ //: @Value(aimAIN1_AIN3 Habilita a leitura diferencial de dados entre as
82+ //: entradas analógicas AIN1 (P) e AIN3 (N))
83+ //: @Value(aimAIN2_AIN3 Habilita a leitura diferencial de dados entre as
84+ //: entradas analógicas AIN2 (P) e AIN3 (N))
85+ //: @Value(aimAIN0_GND Habilita a leitura exclusiva de dados entre as
86+ //: entradas analógicas AIN0 (P) e GND (N))
87+ //: @Value(aimAIN1_GND Habilita a leitura exclusiva de dados entre as
88+ //: entradas analógicas AIN1 (P) e GND (N))
89+ //: @Value(aimAIN2_GND Habilita a leitura exclusiva de dados entre as
90+ //: entradas analógicas AIN2 (P) e GND (N))
91+ //: @Value(aimAIN3_GND Habilita a leitura exclusiva de dados entre as
92+ //: entradas analógicas AIN3 (P) e GND (N))
93+ //: @SeeAlso(InputMultiplexer)
94+ TADS1115InputMultiplexer = (aimAIN0_AIN1,aimAIN0_AIN3,aimAIN1_AIN3,aimAIN2_AIN3,aimAIN0_GND,aimAIN1_GND,aimAIN2_GND,aimAIN3_GND);
95+
6496 //: Esta classe provê acesso simplificado ao ADS1115, um conversor
6597 //: analógico-digital de 16 bits muito popular
6698 //: @Member(AIn0 Obtém o valor da entrada analógica 0, que pode variar de 0
@@ -71,11 +103,14 @@
71103 //: até 32767)
72104 //: @Member(AIn3 Obtém o valor da entrada analógica 3, que pode variar de 0
73105 //: até 32767)
106+ //: @Member(Working Utilize esta propriedade para saber se o ADS1115 está
107+ //: realizando uma conversão, neste caso a propriedade retorna true, do
108+ //: contrário, false)
74109 TADS1115 = class(TCustomPasRipherals)
75110 private
76111 FI2CController: TPRI2CController;
77112 FSlaveAddress: TPRI2CSlaveAddress;
78- FRegisterSelected: TADS1115Register;
113+ FSelectedRegister: TADS1115Register;
79114
80115 //: Seleciona um dos registros do ADS1115. Este método funciona escrevendo
81116 //: dois bits no registrador POINTER a fim de informar ao ADS1115 qual
@@ -113,33 +148,78 @@
113148 //: @Param(AFieldValue Valor a ser escrito no campo)
114149 procedure SetConfigField(AFieldIndex: UInt8; ABitsCount: UInt8; AFieldValue: UInt16);
115150
116- function GetGainAplifier: TADS1115GainAplifier;
117- function GetDataRate: TADS1115DataRate;
118- function GetMode: TADS1115Mode;
151+ function GetConversionRegister: UInt16;
152+
153+ //: Monta um valor que pode ser usado para configurar de uma só vez todos os
154+ //: campos de configuração disponíveis no registrador CONFIG.
155+ //: @Param(AComparatorQueue Leia @Link(ComparatorQueue))
156+ //: @Param(AComparatorLatching Leia @Link(ComparatorLatching))
157+ //: @Param(AComparatorPolarity Leia @Link(ComparatorPolarity))
158+ //: @Param(AComparatorMode Leia @Link(ComparatorMode))
159+ //: @Param(ADataRate Leia @Link(DataRate))
160+ //: @Param(AMode Leia @Link(Mode))
161+ //: @Param(AProgramableGainAplifier Leia @Link(ProgramableGainAplifier))
162+ //: @Param(AInputMultiplexer Leia @Link(InputMultiplexer))
163+ //: @Param(AOperationalStatus Leia @Link(OperationalStatus))
164+ //: @Returns(Valor completo que pode ser usado com a função
165+ //: @Link(SetConfigRegister) para configurar de uma só vez o ADS1115)
166+ function AssembleConfigRegister(AComparatorQueue: TADS1115ComparatorQueue; AComparatorLatching: TADS1115ComparatorLatching; AComparatorPolarity: TADS1115ComparatorPolarity; AComparatorMode: TADS1115ComparatorMode; ADataRate: TADS1115DataRate; AMode: TADS1115Mode; AProgramableGainAplifier: TADS1115ProgramableGainAplifier; AInputMultiplexer: TADS1115InputMultiplexer; AOperationalStatus: Boolean): UInt16;
167+
119168 function GetComparatorQueue: TADS1115ComparatorQueue;
120169 function GetComparatorLatching: TADS1115ComparatorLatching;
121170 function GetComparatorPolarity: TADS1115ComparatorPolarity;
171+ function GetComparatorMode: TADS1115ComparatorMode;
172+ function GetDataRate: TADS1115DataRate;
173+ function GetMode: TADS1115Mode;
174+ function GetGainAplifier: TADS1115ProgramableGainAplifier;
175+ function GetInputMultiplexer: TADS1115InputMultiplexer;
176+ function GetWorking: Boolean;
177+// function GetConversionValue(AInputMultiplexer: TADS1115InputMultiplexer): SmallInt;
122178
179+ //é interessante ter uma propriedade para configurar o mux porque isso evita
180+ //de se ter uma operação de gravação sempre que se for ler um valor analogico
181+ //a forma de fazer será, configura-se sempre o mux correto e obtém o valor
182+ //correspondente. não se pode usar essa biblioteca em threads sem tomar cuidado
183+ //
184+ //Nãosei como proceder :( estou sem ideias. Gravar o mux antes de ler, garante integriade, mas é uma operaçao de escrita a mais
185+ //Não gravar o mux, evita uma escrita, mas a integridade fica comprometida :(
186+
123187 //function GetAIn0: SmallInt;
124188 //function GetAIn1: SmallInt;
125189 //function GetAIn2: SmallInt;
126190 //function GetAIn3: SmallInt;
127191
128- procedure SetGainAplifier(AGainAmplifier: TADS1115GainAplifier);
129- procedure SetDataRate(ADataRate: TADS1115DataRate);
130- procedure SetMode(AMode: TADS1115Mode);
131192 procedure SetComparatorQueue(AComparatorQueue: TADS1115ComparatorQueue);
132193 procedure SetComparatorLatching(ALatchingComparator: TADS1115ComparatorLatching);
133194 procedure SetComparatorPolarity(AComparatorPolarity: TADS1115ComparatorPolarity);
195+ procedure SetComparatorMode(AComparatorMode: TADS1115ComparatorMode);
196+ procedure SetDataRate(ADataRate: TADS1115DataRate);
197+ procedure SetMode(AMode: TADS1115Mode);
198+ procedure SetGainAplifier(AGainAmplifier: TADS1115ProgramableGainAplifier);
199+ procedure SetInputMultiplexer(AInputMultiplexer: TADS1115InputMultiplexer);
134200 public
135201 constructor Create(AI2CController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress); reintroduce;
136202
137- property GainAplifier: TADS1115GainAplifier read GetGainAplifier write SetGainAplifier;
138- property DataRate: TADS1115DataRate read GetDataRate write SetDataRate;
139- property Mode: TADS1115Mode read GetMode write SetMode;
203+ //: Obtém o valor de uma conversão analógica quando o ADS1115 está no modo
204+ //: contínuo de operação. No modo contínuo de operação o ADS1115 já precisa
205+ //: estar previamente configurado antes que esta função possa ser chamada.
206+ //: Use esta função quando pretender ler dados da mesma forma, sempre a
207+ //: partir de uma mesma entrada analógica
208+ //: @Returns(A função retornará um valor entre -32768 e +32767 que
209+ //: corresponde ao valor lido a partir do registrador CONVERSION)
210+ function ConversionValue: SmallInt; overload;
211+ function ConversionValue(AComparatorQueue: TADS1115ComparatorQueue; AComparatorLatching: TADS1115ComparatorLatching; AComparatorPolarity: TADS1115ComparatorPolarity; AComparatorMode: TADS1115ComparatorMode; ADataRate: TADS1115DataRate; AProgramableGainAplifier: TADS1115ProgramableGainAplifier; AInputMultiplexer: TADS1115InputMultiplexer): SmallInt; overload;
212+
140213 property ComparatorQueue: TADS1115ComparatorQueue read GetComparatorQueue write SetComparatorQueue;
141214 property ComparatorLatching: TADS1115ComparatorLatching read GetComparatorLatching write SetComparatorLatching;
142215 property ComparatorPolarity: TADS1115ComparatorPolarity read GetComparatorPolarity write SetComparatorPolarity;
216+ property ComparatorMode: TADS1115ComparatorMode read GetComparatorMode write SetComparatorMode;
217+ property DataRate: TADS1115DataRate read GetDataRate write SetDataRate;
218+ property Mode: TADS1115Mode read GetMode write SetMode;
219+ property GainAplifier: TADS1115ProgramableGainAplifier read GetGainAplifier write SetGainAplifier;
220+ property InputMultiplexer: TADS1115InputMultiplexer read GetInputMultiplexer write SetInputMultiplexer;
221+ property Working: Boolean read GetWorking;
222+ //property SingleShotConversionValue[AInputMultiplexer: TADS1115InputMultiplexer]: SmallInt read GetConversionValue;
143223
144224 { -37768 até 32767}
145225 //property AIn0: SmallInt read GetAIn0;
@@ -167,7 +247,7 @@
167247 CONFIG_DR = 5; CONFIG_DR_SIZE = 3;
168248 CONFIG_MODE = 8; CONFIG_MODE_SIZE = 1;
169249 CONFIG_PGA = 9; CONFIG_PGA_SIZE = 3;
170- CONFIG_MUX = 12; CONFIG_MUX_SOZE = 3;
250+ CONFIG_MUX = 12; CONFIG_MUX_SIZE = 3;
171251 CONFIG_OS = 15; CONFIG_OS_SIZE = 1;
172252
173253
@@ -199,7 +279,7 @@
199279
200280 3. Para ler um dos dois registradores legíveis (CONVERSION E CONFIG), primeiro
201281 use uma operação de escrita para escrever no registrador POINTER o valor que
202- corresponde ao registrador a ser lido. Esta etapa não precis aser realizada
282+ corresponde ao registrador a ser lido. Esta etapa não precisa ser realizada
203283 caso o registrador POINTER já tenha sido configurado para apontar para o
204284 registrador a ser lido em uma operação anterior.
205285
@@ -225,20 +305,32 @@
225305
226306 procedure TADS1115.SelectRegister(ARegister: TADS1115Register);
227307 begin
228- if ARegister <> FRegisterSelected then
308+ if not (ARegister in [FSelectedRegister,arUnknown]) then
229309 begin
230310 I2C[FI2CController,FSlaveAddress].Write8Bits(Byte(ARegister),'Erro ao selecionar o registrador "' + GetEnumName(TypeInfo(TADS1115Register),Ord(ARegister)));
231- FRegisterSelected := ARegister;
311+ FSelectedRegister := ARegister;
232312 end;
233313 end;
234314
235315 function TADS1115.GetConfigRegister: UInt16;
316+var
317+ OriginalSelectedRegister: TADS1115Register;
236318 begin
237- // Seleciona o registrador de configurações
238- SelectRegister(arConfig);
319+ // Guarda o registrador atualmente selecionado
320+ OriginalSelectedRegister := FSelectedRegister;
321+ try
322+ // Seleciona o registrador de configurações
323+ SelectRegister(arConfig);
239324
240- // Lê todo o registrador de configurações
241- I2C[FI2CController,FSlaveAddress].Read16Bits(Result,'Erro ao ler o registrador de configurações',True);
325+ // Lê todo o registrador de configurações
326+ I2C[FI2CController,FSlaveAddress].Read16Bits(Result,'Erro ao ler o registrador de configurações',True);
327+ finally
328+ // Recupera o registrador original, selecionando-o apenas quando
329+ // anteriormente ele já havia sido selecionado. Veja a ajuda para
330+ // TADS1115Register, valor arUnknown
331+ if OriginalSelectedRegister <> arUnknown then
332+ SelectRegister(OriginalSelectedRegister);
333+ end
242334 end;
243335
244336 procedure TADS1115.SetConfigRegister(AConfigurations: UInt16);
@@ -249,10 +341,10 @@
249341 try
250342 // A operação de escrita vai invariavelmente alterar o POINTER, logo, é
251343 // preciso configurar o campo de registro selecionado
252- FRegisterSelected := arConfig;
344+ FSelectedRegister := arConfig;
253345
254346 // Para modificar o registrador de configurações, são necessários 3 bytes
255- WBuffer[0] := Byte(FRegisterSelected); // Aponta para o registrador CONFIG
347+ WBuffer[0] := Byte(FSelectedRegister); // Aponta para o registrador CONFIG
256348
257349 WBuffer[1] := Hi(AConfigurations); // Byte mais significante das configurações
258350 WBuffer[2] := Lo(AConfigurations); // Byte menos significante das configurações
@@ -285,7 +377,39 @@
285377 end;
286378 end;
287379
288-function TADS1115.GetGainAplifier: TADS1115GainAplifier;
380+function TADS1115.GetConversionRegister: UInt16;
381+begin
382+ // A leitura do registrador CONVERSION só deve ser feita quando o campo OS do
383+ // registrador config tiver valor 1, o que significa que o ADS1115 não está
384+ // realizando uma conversão e há um valor válido no registrador CONVERSION. É
385+ // preciso realizar uma espera baseada no status de trabalho, ou seja,
386+ // enquanto o ADS1115 estiver realizando sua tarefa, o programa vai "dormir"
387+ // 100 microsegundos. O tempo foi copiado da biblioteca WiringPi. A espera só
388+ // precisa ser feita no modo Single-Shot, visto que no modo contínuo o ADS1115
389+ // sempre está ocupado e o GetWorking sempre retornará True
390+ if GetMode = amSingleShot then
391+ while GetWorking do
392+ MicroSleep(100);
393+
394+ SelectRegister(arConversion);
395+
396+ I2C[FI2CController,FSlaveAddress].Read16Bits(Result,'Erro ao ler o registrador de conversão',True);
397+end;
398+
399+function TADS1115.AssembleConfigRegister(AComparatorQueue: TADS1115ComparatorQueue; AComparatorLatching: TADS1115ComparatorLatching; AComparatorPolarity: TADS1115ComparatorPolarity; AComparatorMode: TADS1115ComparatorMode; ADataRate: TADS1115DataRate; AMode: TADS1115Mode; AProgramableGainAplifier: TADS1115ProgramableGainAplifier; AInputMultiplexer: TADS1115InputMultiplexer; AOperationalStatus: Boolean): UInt16;
400+begin
401+ Result := UInt8(AOperationalStatus) shl CONFIG_OS
402+ or UInt8(AInputMultiplexer) shl CONFIG_MUX
403+ or UInt8(AProgramableGainAplifier) shl CONFIG_PGA
404+ or UInt8(AMode) shl CONFIG_MODE
405+ or UInt8(ADataRate) shl CONFIG_DR
406+ or UInt8(AComparatorMode) shl CONFIG_COMP_MODE
407+ or UInt8(AComparatorPolarity) shl CONFIG_COMP_POL
408+ or UInt8(AComparatorLatching) shl CONFIG_COMP_LAT
409+ or UInt8(AComparatorQueue) shl CONFIG_COMP_QUE;
410+end;
411+
412+function TADS1115.GetGainAplifier: TADS1115ProgramableGainAplifier;
289413 var
290414 Value: Byte;
291415 begin
@@ -295,11 +419,57 @@
295419 // mesmo ganho, os outros são diferentes entre si e podem ser obtidos a partir
296420 // de um cast direto
297421 if Value > 4 then
298- Result := aga16
422+ Result := apga16
299423 else
300- Result := TADS1115GainAplifier(Value);
424+ Result := TADS1115ProgramableGainAplifier(Value);
301425 end;
302426
427+function TADS1115.GetInputMultiplexer: TADS1115InputMultiplexer;
428+begin
429+ Result := TADS1115InputMultiplexer(GetConfigField(CONFIG_MUX,CONFIG_MUX_SIZE));
430+end;
431+
432+function TADS1115.GetWorking: Boolean;
433+begin
434+ // O valor é negado porque ao ler o campo OS, zero significa que está sendo
435+ // realizada uma conversão e um significa que o ADS1115 está ocioso
436+ Result := not GetConfigField(CONFIG_OS,CONFIG_OS_SIZE).ToBoolean;
437+end;
438+
439+//function TADS1115.GetConversionValue(AInputMultiplexer: TADS1115InputMultiplexer): SmallInt;
440+//begin
441+
442+ //case GetMode of
443+ // amContinuous: begin
444+ // //SelectRegister(arConversion);
445+ // // if GetInputMultiplexer <> AInputMultiplexer
446+ // // Como implementar ester modo de forma que seja eficiente quanto as
447+ // // escritas e leituras
448+ //
449+ // end;
450+ // amSingleShot: begin
451+ //
452+ // end;
453+ //end;
454+ //
455+ //
456+ //
457+ //verificar se o modo é continuo ou single shot
458+ //verificar como o modo continuo funciona pra saber se dá pra usar a mesma estrategia do single shot
459+
460+// case AInputMultiplexer of
461+// aimAIN0_AIN1:
462+// aimAIN0_AIN3:
463+// aimAIN1_AIN3:
464+// aimAIN2_AIN3:
465+// aimAIN0_GND:
466+// aimAIN1_GND:
467+// aimAIN2_GND:
468+// aimAIN3_GND:
469+// else { aimLastUsedOne }
470+// end;
471+//end;
472+
303473 function TADS1115.GetDataRate: TADS1115DataRate;
304474 begin
305475 Result := TADS1115DataRate(GetConfigField(CONFIG_DR,CONFIG_DR_SIZE));
@@ -325,6 +495,11 @@
325495 Result := TADS1115ComparatorPolarity(GetConfigField(CONFIG_COMP_POL,CONFIG_COMP_POL_SIZE));
326496 end;
327497
498+function TADS1115.GetComparatorMode: TADS1115ComparatorMode;
499+begin
500+ Result := TADS1115ComparatorMode(GetConfigField(CONFIG_COMP_MODE,CONFIG_COMP_MODE_SIZE));
501+end;
502+
328503 //function TADS1115.GetAIn0: SmallInt;
329504 //begin
330505 //{ Configure o mux para single end (100) antes de ler o valor
@@ -349,11 +524,16 @@
349524 //
350525 //end;
351526
352-procedure TADS1115.SetGainAplifier(AGainAmplifier: TADS1115GainAplifier);
527+procedure TADS1115.SetGainAplifier(AGainAmplifier: TADS1115ProgramableGainAplifier);
353528 begin
354529 SetConfigField(CONFIG_PGA,CONFIG_PGA_SIZE,UInt8(AGainAmplifier));
355530 end;
356531
532+procedure TADS1115.SetInputMultiplexer(AInputMultiplexer: TADS1115InputMultiplexer);
533+begin
534+ SetConfigField(CONFIG_MUX,CONFIG_MUX_SIZE,UInt8(AInputMultiplexer));
535+end;
536+
357537 procedure TADS1115.SetDataRate(ADataRate: TADS1115DataRate);
358538 begin
359539 SetConfigField(CONFIG_DR,CONFIG_DR_SIZE,UInt8(ADataRate));
@@ -379,13 +559,55 @@
379559 SetConfigField(CONFIG_COMP_POL,CONFIG_COMP_POL_SIZE,UInt8(AComparatorPolarity));
380560 end;
381561
562+procedure TADS1115.SetComparatorMode(AComparatorMode: TADS1115ComparatorMode);
563+begin
564+ SetConfigField(CONFIG_COMP_MODE,CONFIG_COMP_MODE_SIZE,UInt8(AComparatorMode));
565+end;
566+
382567 constructor TADS1115.Create(AI2CController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress);
383568 begin
384569 inherited Create;
385570 FI2CController := AI2CController;
386571 FSlaveAddress := ASlaveAddress;
387- FRegisterSelected := arUnknown;
572+ FSelectedRegister := arUnknown;
388573 end;
389574
575+function TADS1115.ConversionValue: SmallInt;
576+begin
577+ if GetMode = amSingleShot then
578+ raise EADS1115.Create('Esta função é projetada para ser usada no modo "contínuo" mas o modo atual é "single-shot". Por favor use a outra versão desta função ou altere o modo');
579+
580+ // A conversão gera um número de 16 bits puro (0 a FFFF), porém a
581+ // interpretação precisa estar dentro de um inteiro de 16 bits com sinal. Tais
582+ // inteiros variam de -32768 a +32767. De 1 a 7FFF (1 a 32767) estão os
583+ // valores positivos (1 a 32767) e de 8000 a FFFF (32768 a 65535) estão os
584+ // valores negativos (-32768 a -1)
585+
586+ Result := GetConversionRegister;
587+end;
588+
589+function TADS1115.ConversionValue(AComparatorQueue: TADS1115ComparatorQueue; AComparatorLatching: TADS1115ComparatorLatching; AComparatorPolarity: TADS1115ComparatorPolarity; AComparatorMode: TADS1115ComparatorMode; ADataRate: TADS1115DataRate; AProgramableGainAplifier: TADS1115ProgramableGainAplifier; AInputMultiplexer: TADS1115InputMultiplexer): SmallInt;
590+begin
591+ if GetMode = amContinuous then
592+ raise EADS1115.Create('Esta função é projetada para ser usada no modo "single-shot" mas o modo atual é "contínuo". Por favor use a outra versão desta função ou altere o modo');
593+
594+ // Configura todos os campos do registrador CONFIG de uma só vez, exceto os
595+ // campos MODE e OS, os quais são configurados sempre com os valores
596+ // amSingleShot e True, respectivamente, já que aqui estamos realizando uma
597+ // leitura no modo single-shot. A configuração do registrador CONFIG com o
598+ // campo OS = 1 inicia a conversão imediatamente
599+ SetConfigRegister(AssembleConfigRegister(AComparatorQueue
600+ ,AComparatorLatching
601+ ,AComparatorPolarity
602+ ,AComparatorMode
603+ ,ADataRate
604+ ,amSingleShot
605+ ,AProgramableGainAplifier
606+ ,AInputMultiplexer
607+ ,True));
608+
609+ Result := GetConversionRegister;
610+end;
611+
390612 end.
391613
--- trunk/src/lib/UPasRipherals.pas (revision 28)
+++ trunk/src/lib/UPasRipherals.pas (revision 29)
@@ -760,8 +760,8 @@
760760 procedure PeripheralsBaseAddressAndSize(out ABaseAdddress: UInt32; out ASize: UInt32);
761761
762762 procedure NanoSleep(ANanoSeconds: Uint16);
763+ protected
763764 procedure MicroSleep(AMicroSeconds: Uint16);
764- protected
765765 //: Use esta função para retornar o valor de um conjunto de bits dentro de
766766 //: um registrador de até 32 bits de tamanho
767767 function GetBitsValue(ARegister: UInt32; ABitIndex: UInt8; ABitsCount: UInt8 = 1): UInt32;
@@ -1315,9 +1315,6 @@
13151315
13161316 function TPRI2C.Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult;
13171317 begin
1318- if AValue <= High(Byte) then
1319- raise Exception.Create('O valor do parâmetro precisa estar compreendido entre 256 e 65535');
1320-
13211318 // Troca a posição dos bytes em AValue.
13221319 if ASwapBytes then
13231320 AValue := Swap(AValue);
Show on old repository browser