• R/O
  • SSH
  • HTTPS

pasripherals: Commit


Commit MetaInfo

Revision35 (tree)
Time2019-10-04 11:37:14
Authorderekwildstar

Log Message

Documentação atualizada
Classes renomeadas

Change Summary

Incremental Difference

--- trunk/src/lib/UADS1115.pas (revision 34)
+++ trunk/src/lib/UADS1115.pas (revision 35)
@@ -161,8 +161,8 @@
161161 //: contrário, false)
162162 TADS1115 = class(TCustomPasRipherals)
163163 private
164- FI2CController: TPRI2CController;
165- FSlaveAddress: TPRI2CSlaveAddress;
164+ FI2CController: TI2CController;
165+ FSlaveAddress: TI2CSlaveAddress;
166166 FSelectedRegister: TADS1115Register;
167167
168168 //: Seleciona um dos registros do ADS1115. Este método funciona escrevendo
@@ -237,7 +237,7 @@
237237 procedure SetGainAplifier(AGainAmplifier: TProgramableGainAplifier);
238238 procedure SetInputMultiplexer(AInputMultiplexer: TADS1115InputMultiplexer);
239239 public
240- constructor Create(AI2CController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress); reintroduce;
240+ constructor Create(AI2CController: TI2CController; ASlaveAddress: TI2CSlaveAddress); reintroduce;
241241
242242 //: Obtém o valor de uma conversão analógica quando o ADS1115 está no modo
243243 //: contínuo de operação. No modo contínuo de operação o ADS1115 já precisa
@@ -543,7 +543,7 @@
543543 SetConfigField(CONFIG_COMP_MODE,CONFIG_COMP_MODE_SIZE,UInt8(AComparatorMode));
544544 end;
545545
546-constructor TADS1115.Create(AI2CController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress);
546+constructor TADS1115.Create(AI2CController: TI2CController; ASlaveAddress: TI2CSlaveAddress);
547547 begin
548548 inherited Create;
549549 FI2CController := AI2CController;
--- trunk/src/lib/UPasRipherals.pas (revision 34)
+++ trunk/src/lib/UPasRipherals.pas (revision 35)
@@ -456,13 +456,13 @@
456456 //: Este tipo enumerado define os tipos de "mash" de clocks disponíveis A
457457 //: página 105 do DataSheet fala um pouco a respeito do MASH, mas de forma bem
458458 //: superficial.
459- //: @value(prcmInteger Este valor indica que está sendo usado um divisor
459+ //: @value(cmInteger Este valor indica que está sendo usado um divisor
460460 //: inteiro)
461- //: @value(prcm1Stage Este valor indica que está sendo usado um divisor
461+ //: @value(cm1Stage Este valor indica que está sendo usado um divisor
462462 //: fracionário de 1 estágio)
463- //: @value(prcm2Stage Este valor indica que está sendo usado um divisor
463+ //: @value(cm2Stage Este valor indica que está sendo usado um divisor
464464 //: fracionário de 2 estágios)
465- //: @value(prcm3Stage Este valor indica que está sendo usado um divisor
465+ //: @value(cm3Stage Este valor indica que está sendo usado um divisor
466466 //: fracionário de 3 estágios)
467467 TClockMash = (cmInteger, cm1Stage, cm2Stage, cm3Stage);
468468 (* doc.ok *)
@@ -498,9 +498,13 @@
498498 private
499499 FClockId: TClockId;
500500 FPasRipherals: TCustomPasRipherals;
501- continue aqui, descrevendo os dois registerXXXX e melhorando a descrição da
502- funcao configure mais adiante
501+ (* doc.ok *)
502+ //: Esta função retorna um ponteiro para o registrador CTL, cujos campos são
503+ //: explicados com detalhes na páginas 107 do DataSheet
503504 function RegisterCTL: PUInt32;
505+ (* doc.ok *)
506+ //: Esta função retorna um ponteiro para o registrador DIV, cujos campos são
507+ //: explicados com detalhes na páginas 108 do DataSheet
504508 function RegisterDIV: PUInt32;
505509
506510 function GetSource: TClockSource;
@@ -523,15 +527,25 @@
523527 property DivI: TClockDivI read GetDivI write SetDivI;
524528 property DivF: TClockDivF read GetDivF write SetDivF;
525529 property Divisor: Double read GetDivisor;
530+ (* doc.ok *)
526531 //: Configura todas as características do clock atual de uma só vez.
527- //:
528- //: Ao configurar o clock do PWM, use um divisor que gere um clock
529- //: suficientemente grande para garantir o funcionamento adequado.
530- //: Normalmente usar um divisor inteiro e igual a 2 é suficiente. Diminua o
531- //: clock apenas se for necessário
532+ //: @Param(ASource Informe neste parâmetro a fonte do clock, em outras
533+ //: palavras qual hardware irá gerar os pulsos de clock)
534+ //: @Param(AMash Informe o mash, que define qual será o tipo de divisor de
535+ //: clock a ser usado)
536+ //: @Param(ADivI Valor da parte inteira do divisor)
537+ //: @Param(ADivF Valor da parte fracionária do divisor, utilizado quando
538+ //: AMash tem um valor diferente de cmInteger)
539+ //: @Param(AEnable Quando true, o clock será habilitado após ser
540+ //: configurado. Quando false, apenas será feita sua configuração)
541+ //: @SeeAlso(TClockSource)
542+ //: @SeeAlso(TClockMash)
543+ //: @SeeAlso(TClockDivI)
544+ //: @SeeAlso(TClockDivF)
532545 procedure Configure(ASource: TClockSource; AMash: TClockMash; ADivI: TClockDivI; ADivF: TClockDivF; AEnabled: Boolean);
533546 end;
534547
548+ (* doc.ok *)
535549 //: Existem 3 controladores BSC principais: BSC0, BSC1 e BSC2. O BSC2 é usado
536550 //: exclusivamente pelo HDMI e não deve ser usado em programas, por isso
537551 //: apenas os controladores 0 e 1 são acessíveis. O BSC1 encontra-se nos GPIO
@@ -543,51 +557,56 @@
543557 //: execuções da função "ioctl". A título de informação, o dispositivo
544558 //: "/dev/i2c-1" correspomde ao BSC1. Esta enumeração lista apenas os
545559 //: controladores que são efetivamente acessáveis, atualmente o BSC0 e o BSC1
546- //: @value(pricBSC0 Indica que estamos acessando o controlador 0)
547- //: @value(pricBSC1 Indica que estamos acessando o controlador 1, também
560+ //: @Value(icBSC0 Indica que estamos acessando o controlador 0)
561+ //: @Value(icBSC1 Indica que estamos acessando o controlador 1, também
548562 //: conhecido em outras bibliotecas como "/dev/i2c-1")
549- TPRI2CController = (pricBSC0, pricBSC1);
563+ TI2CController = (icBSC0, icBSC1);
564+ (* doc.ok *)
550565 //: O valor máximo de um endereço de dispositivo I2C é 127, pois o registrador
551566 //: A define que apenas os 7 primeiros bits (ADDR) são usados para definir
552567 //: este endereço. Este subtipo limita os valores pessíveis
553- TPRI2CSlaveAddress = 0..127;
568+ TI2CSlaveAddress = 0..127;
569+ (* doc.ok *)
554570 //: Esta enumeração representa o valor do campo READ do registrador C
555- //: @value(prittWrite A transferência está configurada para escrever no
571+ //: @Value(ittWrite A transferência está configurada para escrever no
556572 //: dispositivo I2C)
557- //: @value(prittRead A transferência está configurada para ler a partir do
573+ //: @Value(ittRead A transferência está configurada para ler a partir do
558574 //: dispositivo I2C)
559- TPRI2CTransferType = (prittWrite, prittRead);
575+ TI2CTransferType = (ittWrite, ittRead);
576+ (* doc.ok *)
560577 //: Esta enumeração representa os possíves retornos das funções
561- //: @link(TPRI2C.Read) e @link(TPRI2C.Write)
562- //: @value(pritrSuccess A transferência de dados foi bem sucedida)
563- //: @value(pritrNak O dispositivo escravo enviou um NAK (Negative
578+ //: @Link(TI2C.Read) e @Link(TI2C.Write)
579+ //: @Value(itrSuccess A transferência de dados foi bem sucedida)
580+ //: @Value(itrNak O dispositivo escravo enviou um NAK (Negative
564581 //: Acknoledgement))
565- //: @value(pritrTimeOut O dispositivo escravo demorou muito para responder,
566- //: mantendo, segundo o datasheet p. 31, o sinal SCL alto por tempo de mais)
567- //: @value(pritrInsufficientData A quantidade de dados transferidos foi
582+ //: @Value(itrTimeOut O dispositivo escravo demorou muito para responder,
583+ //: mantendo, segundo o DataSheet p. 31, o sinal SCL alto por tempo demais)
584+ //: @Value(itrInsufficientData A quantidade de dados transferidos foi
568585 //: inferior ao valor definido no parâmetro ABufferSize)
569- TPRI2CTransferResult = (pritrSuccess,pritrNak,pritrTimeOut,pritrInsufficientData);
586+ TI2CTransferResult = (itrSuccess,itrNak,itrTimeOut,itrInsufficientData);
570587
571- { TPRI2C }
588+ { TI2C }
572589
573- //: I2C
574- //: @member(TransferType Informa o tipo de transferência, que pode ser leitura
590+ (* doc.ok *)
591+ //: Este record representa um dispositivo escravo conectado ao barramento I2C
592+ //: acessado a partir da classe TPasRipherals
593+ //: @Member(TransferType Informa o tipo de transferência, que pode ser leitura
575594 //: ou escrita. Esta propriedade corresponde ao campo READ do registrador
576- //: C. Para mais informações leia a respeito de @link(TPRI2CTransferType))
577- //: @member(SlaveAddress Define o endreço do dispositivo que se quer acessar.
595+ //: C. Para mais informações leia a respeito de @Link(TI2CTransferType))
596+ //: @Member(SlaveAddress Define o endreço do dispositivo que se quer acessar.
578597 //: Esta propriedade corresponde ao campo ADDR do registrador A. Para mais
579- //: informações leia a respeito de @link(TPRI2CSlaveAddress))
580- //: @member(Enabled indica se o controlador BSC está ativado ou não. Esta
598+ //: informações leia a respeito de @link(TI2CSlaveAddress))
599+ //: @Member(Enabled indica se o controlador BSC está ativo ou não. Esta
581600 //: propriedade corresponde ao campo I2CEN do registrador C)
582- //: @member(TransferActive Esta propriedade informa se á alguma transferência
601+ //: @Member(TransferActive Esta propriedade informa se á alguma transferência
583602 //: ativa. Ela corresponde ao campo TA do registrdor S)
584- //: @member(TransferDone Esta propriedade assume o valor true quando a
603+ //: @Member(TransferDone Esta propriedade assume o valor true quando a
585604 //: transferência for concluída. Ela é uma propriedade cuja escrita tem a
586605 //: função especial de "ressetar" o campo correspondente (campo DONE do
587606 //: registrador S), portanto, apenas configure esta propriedade como True com
588607 //: o intuito de ressetá-la. Configurar esta propriedade como false, não tem
589608 //: efeito algum)
590- //: @member(Nak Esta propriedade assume o valor true quando o dispositivo
609+ //: @Member(Nak Esta propriedade assume o valor true quando o dispositivo
591610 //: referenciado não reconhece seu endereço ou os dados escritos nele
592611 //: (negative acknowledgement). Esta propriedade é uma propriedade cuja
593612 //: escrita tem a função especial de "ressetar" o campo correspondente (campo
@@ -594,7 +613,7 @@
594613 //: ERR do registrador S), portanto, apenas configure esta propriedade como
595614 //: True com o intuito de ressetá-la. Configurar esta propriedade como false,
596615 //: não tem efeito algum)
597- //: @member(TimeOut Esta propriedade assume o valor true quando o dispositivo
616+ //: @Member(TimeOut Esta propriedade assume o valor true quando o dispositivo
598617 //: mantém o sinal SCL num mesmo estado por um período muido longo, o que
599618 //: configura a condição de erro conhecida por "clock stretching". Esta
600619 //: propriedade é uma propriedade cuja escrita tem a função especial de
@@ -601,7 +620,7 @@
601620 //: "ressetar" o campo correspondente (campo CLKT do registrador S), portanto,
602621 //: apenas configure esta propriedade como True com o intuito de ressetá-la.
603622 //: Configurar esta propriedade como false, não tem efeito algum)
604- //: @member(DataLength Esta propriedade corresponde ao campo DLEN do
623+ //: @Member(DataLength Esta propriedade corresponde ao campo DLEN do
605624 //: registrador DLEN. Ao escrever nela se está definindo a quantidade de bytes
606625 //: que serão lidos ou escritos, dependendo da operação ativa
607626 //: (@link(TransferType)). O valor lido desta propriedade quando
@@ -613,27 +632,38 @@
613632 //:
614633 //: OBS.: Este texto foi todo traduzido a partir do datasheet. Não foi
615634 //: possível entender muito bem)
616- //: @member(FIFOContainsData Se o valor desta propriedade for true, o FIFO
635+ //: @Member(FIFOContainsData Se o valor desta propriedade for true, o FIFO
617636 //: contém ao menos 1 byte. Se o valor for false, o FIFO está vazio. Esta
618637 //: propriedade corresponde ao campo RXD do registrador S)
619- //: @member(FIFOCanAcceptData Se o valor dessa propriedade for false, o FIFO
638+ //: @Member(FIFOCanAcceptData Se o valor dessa propriedade for false, o FIFO
620639 //: está cheio, do contrário o FIFO tem espaço para pelo menos 1 byte. Esta
621640 //: propriedade corresponde ao campo TXD do registrador S)
622- TPRI2C = record
641+ TI2C = record
623642 private
624- FController: TPRI2CController;
643+ FController: TI2CController;
625644 FPasRipherals: TCustomPasRipherals;
626645
646+ (* doc.ok *)
647+ //: Esta função retorna um ponteiro para o registrador C, cujos campos são
648+ //: explicados com detalhes nas páginas 29 e 30 do DataSheet
627649 function RegisterC: PUInt32;
650+ (* doc.ok *)
651+ //: Esta função retorna um ponteiro para o registrador S, cujos campos são
652+ //: explicados com detalhes nas páginas 31 e 32 do DataSheet
628653 function RegisterS: PUInt32;
654+ (* doc.ok *)
655+ //: Esta função retorna um ponteiro para o registrador S, cujos campos são
656+ //: explicados com detalhes nas páginas 32 e 33 do DataSheet
629657 function RegisterDLEN: PUInt32;
630- //: O registrador A contém apenas um campo ADDR (Slave Address) de 7 bits
631- //: que deve conter o endreço do dispositivo a ser acessado. Segundo
632- //: literatura online, internamente o I2C usa dois valores de endreço, um
633- //: para escrita e outro para leitura e ambos estes valores derivam do
634- //: endereço do dispositivo. O que é feito nos bastidores é que é dado shift
635- //: left no valor do endereço e o bit menos significante dentre oito bits,
636- //: indicará a operação, 1 para leitura e 0 para escrita.
658+ (* doc.ok *)
659+ //: Esta função retorna um ponteiro para o registrador A, que contém apenas
660+ //: um campo ADDR (Slave Address) de 7 bits que deve conter o endreço do
661+ //: dispositivo a ser acessado. Segundo literatura online, internamente o
662+ //: I2C usa dois valores de endreço, um para escrita e outro para leitura e
663+ //: ambos estes valores derivam do endereço do dispositivo. O que é feito
664+ //: nos bastidores é que é dado um shift left no valor do endereço e o bit
665+ //: menos significante dentre oito bits, indicará a operação, 1 para leitura
666+ //: e 0 para escrita.
637667 //:
638668 //: Considere o endereço 0x48, cuja forma binária é 0100 1000. Internamente,
639669 //: caso uma operação de leitura for solicitada para este endereço, a
@@ -646,14 +676,26 @@
646676 //: mantendo no bit menos significante o valor zero, que neste caso indica
647677 //: uma operação de escrita
648678 function RegisterA: PUInt32;
679+ (* doc.ok *)
680+ //: Esta função retorna um ponteiro para o registrador FIFO, cujo únic campo
681+ //: (DATA) é explicado com detalhes na página 33 do DataSheet
649682 function RegisterFIFO: PUInt32;
683+ (* doc.ok *)
684+ //: Esta função retorna um ponteiro para o registrador DIV, cujo únic campo
685+ //: (CDIV) é explicado com detalhes na página 34 do DataSheet
650686 function RegisterDIV: PUInt32;
687+ (* doc.ok *)
688+ //: Esta função retorna um ponteiro para o registrador DEL, cujos campos são
689+ //: explicados com detalhes na página 34 do DataSheet
651690 function RegisterDEL: PUInt32;
691+ (* doc.ok *)
692+ //: Esta função retorna um ponteiro para o registrador CLKT, cujo únic campo
693+ //: (TOUT) é explicado com detalhes na página 35 do DataSheet
652694 function RegisterCLKT: PUint32;
653695
654- procedure SetSlaveAddress(ASalaveAddress: TPRI2CSlaveAddress);
696+ procedure SetSlaveAddress(ASalaveAddress: TI2CSlaveAddress);
655697
656- function GetTransferType: TPRI2CTransferType;
698+ function GetTransferType: TI2CTransferType;
657699 function GetEnabled: Boolean;
658700 function GetTransferActive: Boolean;
659701 function GetTransferDone: Boolean;
@@ -670,34 +712,37 @@
670712 procedure SetDataLength(ADataLength: UInt16);
671713 procedure SetFIFO(AValue: UInt8);
672714 public
715+ (* doc.ok *)
673716 //: Limpa o campo DATA do registrador FIFO, escrevendo 1 no campo CLEAR do
674717 //: registrador C
675718 procedure ClearFIFO;
719+ (* doc.ok *)
676720 //: Resseta os campos DONE, ERR e CLKT do registrador S escrevendo 1 nestes
677721 //: campos
678722 procedure ResetStatus;
723+ (* doc.ok *)
679724 //: Inicia a transferência do, ou para o, dispositivo escravo, escrevendo 1
680725 //: no campo ST do registrador C. Este método também habilita o controlador
681726 //: BSC escrevendo 1 no campo I2CEN do mesmo registrador
682- //: @param(ATransferType Indica o tipo de transferência a iniciar)
683- //: @param(AClearFifo Quando true, também limpa o FIFO em uma única
684- //: operação. Segundo o datasheet, caso o campo ST do registrador C seja
727+ //: @Param(ATransferType Indica o tipo de transferência a iniciar)
728+ //: @Param(AClearFifo Quando true, também limpa o FIFO em uma única
729+ //: operação. Segundo o DataSheet, caso o campo ST do registrador C seja
685730 //: configurado como 1 ao mesmo tempo que o campo CLEAR do mesmo
686- //: registrador também o seja, é garanti do que o FIFO será limpo antes do
731+ //: registrador também o seja, é garantido que o FIFO será limpo antes do
687732 //: início da transferência)
688- //: @seealso(TPRI2CTransferType)
689- procedure StartTransfer(ATransferType: TPRI2CTransferType; AClearFifo: Boolean = False);
690-
733+ //: @SeeAlso(TI2CTransferType)
734+ procedure StartTransfer(ATransferType: TI2CTransferType; AClearFifo: Boolean = False);
735+ (* doc.ok *)
691736 //: Lê uma determinada quantidade de bytes a partir do dispositivo escravo.
692737 //: Este método funciona lendo bytes a partir do FIFO.
693738 //:
694- //: Segundo o que eu pude entender do datasheet (p. 33) o registrador FIFO,
739+ //: Segundo o que eu pude entender do DataSheet (p. 33) o registrador FIFO,
695740 //: por meio do seu campo DATA de apenas 8 bits, é apenas a "porta" para o
696741 //: FIFO "real" que tem 16 bytes de tamanho total. Acredito que este FIFO de
697742 //: 16 bytes seja um buffer, o qual é lido por meio do registrador FIFO, de
698743 //: 8 em 8 bits (1 em 1 Byte) até que não haja mais nenhum byte a ser lido a
699744 //: partir do FIFO "real". Uma pista para este comportamento é a descrição
700- //: do campo RXD do registrador S. Segundo o datasheet "quando o campo RXD
745+ //: do campo RXD do registrador S. Segundo o DataSheet "quando o campo RXD
701746 //: contém 1, significa que o FIFO contém <<pelo menos>> 1 byte". Ora, se o
702747 //: FIFO mencionado fosse o registrador, não faria sentido falar em "pelo
703748 //: menos", já que o campo DATA do registrador FIFO só comporta no máximo 1
@@ -711,8 +756,9 @@
711756 //: será usado pela função para inicializar a variável retornada no
712757 //: parâmetro ABuffer)
713758 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
714- //: @Link(TPRI2CTransferResult))
715- function Read(out ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult; overload;
759+ //: @Link(TI2CTransferResult))
760+ function Read(out ABuffer: PUInt8; ABufferSize: UInt32): TI2CTransferResult; overload;
761+ (* doc.ok *)
716762 //: Esta função lê 2 Bytes (16 bits) a partir do dispositivo escravo, lendo
717763 //: 2 bytes a partir do FIFO.
718764 //: @Param(AValue Este parâmetro de saída recebe os dois bytes lidos)
@@ -741,8 +787,9 @@
741787 //: simplemente um efeito colataral da forma de envio dos bytes através de
742788 //: um buffer FIFO)
743789 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
744- //: @Link(TPRI2CTransferResult))
745- function Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult; overload;
790+ //: @Link(TI2CTransferResult))
791+ function Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TI2CTransferResult; overload;
792+ (* doc.ok *)
746793 //: Esta função lê 2 Bytes (16 bits) a partir do dispositivo escravo, lendo
747794 //: 2 bytes a partir do FIFO de forma protegida. Ela levanta exceções em
748795 //: caso de erros. Após executar esta função, caso o fluxo de execução passe
@@ -756,14 +803,16 @@
756803 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
757804 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
758805 //: da falha)
759- //: @SeeAlso(TPRI2CTransferResult)
806+ //: @SeeAlso(TI2CTransferResult)
760807 procedure Read16Bits(out AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean); overload;
808+ (* doc.ok *)
761809 //: Esta função lê 1 Byte (8 bits) a partir do dispositivo escravo, lendo
762810 //: 1 byte a partir do FIFO.
763811 //: @Param(AValue Este parâmetro de saída recebe o Byte lido)
764812 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
765- //: @Link(TPRI2CTransferResult))
766- function Read8Bits(out AValue: UInt8): TPRI2CTransferResult; overload;
813+ //: @Link(TI2CTransferResult))
814+ function Read8Bits(out AValue: UInt8): TI2CTransferResult; overload;
815+ (* doc.ok *)
767816 //: Esta função lê 1 Byte (8 bits) a partir do dispositivo escravo, lendo
768817 //: 1 byte a partir do FIFO de forma protegida. Ela levanta exceções em
769818 //: caso de erro. Após executar esta função, caso o fluxo de execução passe
@@ -775,8 +824,9 @@
775824 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
776825 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
777826 //: da falha)
778- //: @SeeAlso(TPRI2CTransferResult)
827+ //: @SeeAlso(TI2CTransferResult)
779828 procedure Read8Bits(out AValue: UInt8; ABaseErrorMessage: String); overload;
829+ (* doc.ok *)
780830 //: Escreve uma determinada quantidade de bytes no dispositivo escravo. Este
781831 //: método funciona escrevendo bytes no FIFO.
782832 //: @Param(ABuffer Memória que contém os bytes a serem escritos)
@@ -783,9 +833,10 @@
783833 //: @Param(ABufferSize Quantidade de bytes a serem escritos. Normalmente
784834 //: este valor é o mesmo valor utilizado para inicializar a variável que
785835 //: será passada em ABuffer)
786- //: @Returns(A função retorna um dos possíveis valores da enumeraçao
787- //: @Link(TPRI2CTransferResult))
788- function Write(const ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult; overload;
836+ //: @Returns(A função retorna um dos possíveis valores da enumeração
837+ //: @Link(TI2CTransferResult))
838+ function Write(const ABuffer: PUInt8; ABufferSize: UInt32): TI2CTransferResult; overload;
839+ (* doc.ok *)
789840 //: Escreve uma determinada quantidade de bytes no dispositivo escravo. Este
790841 //: método funciona escrevendo bytes no FIFO de forma protegida. Ela levanta
791842 //: exceções em caso de erros. Após executar esta função, caso o fluxo de
@@ -800,8 +851,9 @@
800851 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
801852 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
802853 //: da falha)
803- //: @SeeAlso(TPRI2CTransferResult)
854+ //: @SeeAlso(TI2CTransferResult)
804855 procedure Write(const ABuffer: PUInt8; ABufferSize: UInt32; ABaseErrorMessage: String); overload;
856+ (* doc.ok *)
805857 //: Esta função escreve 2 Bytes (16 bits) no dispositivo escravo, escrevendo
806858 //: 2 Byte no FIFO. @Bold(ATENÇÃO: NÃO UTILIZE ESTA FUNÇÃO PARA ESCREVER
807859 //: VALORES DE 8 BITS. PARA ESSA FINALIDADE, USE UMA DAS FORMAS DA FUNÇÃO
@@ -810,7 +862,8 @@
810862 //: @Param(ASwapBytes Caso este parâmetro seja true, os Bytes em AValue são
811863 //: trocados de posição)
812864 //: @SeeAlso(Read16Bits)
813- function Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult; overload;
865+ function Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TI2CTransferResult; overload;
866+ (* doc.ok *)
814867 //: Esta função escreve 2 Bytes (16 bits) no dispositivo escravo, escrevendo
815868 //: 2 Byte no FIFO de forma protegida. Ela levanta exceções em caso de
816869 //: erros. Após executar esta função, caso o fluxo de execução passe dela,
@@ -826,14 +879,16 @@
826879 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
827880 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
828881 //: da falha)
829- //: @SeeAlso(TPRI2CTransferResult)
882+ //: @SeeAlso(TI2CTransferResult)
830883 procedure Write16Bits(AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean); overload;
884+ (* doc.ok *)
831885 //: Esta função escreve 1 Byte (8 bits) no dispositivo escravo, escrevendo
832886 //: 1 Byte no FIFO.
833887 //: @Param(AValue Valor a ser escrito)
834888 //: @Returns(A função retorna um dos possíveis valores da enumeraçao
835- //: @Link(TPRI2CTransferResult))
836- function Write8Bits(AValue: UInt8): TPRI2CTransferResult; overload;
889+ //: @Link(TI2CTransferResult))
890+ function Write8Bits(AValue: UInt8): TI2CTransferResult; overload;
891+ (* doc.ok *)
837892 //: Esta função escreve 1 Byte (8 bits) no dispositivo escravo, escrevendo
838893 //: 1 Byte no FIFO de forma protegida. Ela levanta exceções em caso de
839894 //: erros. Após executar esta função, caso o fluxo de execução passe dela,
@@ -845,10 +900,10 @@
845900 //: @Raises(EPasRipherals Esta exceção é levantada com a mensagem de erro
846901 //: informada em ABaseErrorMessage, concatenada com um dos possíveis motivos
847902 //: da falha)
848- //: @SeeAlso(TPRI2CTransferResult)
903+ //: @SeeAlso(TI2CTransferResult)
849904 procedure Write8Bits(AValue: UInt8; ABaseErrorMessage: String); overload;
850905
851- property TransferType: TPRI2CTransferType read GetTransferType;
906+ property TransferType: TI2CTransferType read GetTransferType;
852907 property TransferActive: Boolean read GetTransferActive;
853908 property FIFOContainsData: Boolean read GetFIFOContainsData;
854909 property FIFOCanAcceptData: Boolean read GetFIFOCanAcceptData;
@@ -903,7 +958,7 @@
903958 function GetClock(AClockId: TClockId): TClock;
904959 function GetGPIO(AGPIONumber: TGPIONumber): TGPIO;
905960 function GetPWM(APWMChannel: TPWMChannel): TPWM;
906- function GetI2C(AController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress): TPRI2C;
961+ function GetI2C(AController: TI2CController; ASlaveAddress: TI2CSlaveAddress): TI2C;
907962
908963 function GetLevels(ALevelBank: TPRGPIOLevelBank): UInt32;
909964 function GetModes(AModeBank: TGPIOModeBank): UInt32;
@@ -938,7 +993,7 @@
938993 property Clock[AClockId: TClockId]: TClock read GetClock;
939994 property GPIO[AGPIONumber: TGPIONumber]: TGPIO read GetGPIO;
940995 property PWM[APWMChannel: TPWMChannel]: TPWM read GetPWM;
941- property I2C[AController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress]: TPRI2C read GetI2C;
996+ property I2C[AController: TI2CController; ASlaveAddress: TI2CSlaveAddress]: TI2C read GetI2C;
942997 property GPIOLevels[ALevelBank: TPRGPIOLevelBank]: UInt32 read GetLevels write SetLevels;
943998 property GPIOModes[AModeBank: TGPIOModeBank]: UInt32 read GetModes write SetModes;
944999 property State: TSavedState read GetState write SetState;
@@ -1124,173 +1179,173 @@
11241179
11251180 BSC_FIFO_DATA = 0; BSC_FIFO_DATA_SIZE = 8;
11261181
1127-{ TPRI2C }
1182+{ TI2C }
11281183
1129-function TPRI2C.RegisterC: PUInt32;
1184+function TI2C.RegisterC: PUInt32;
11301185 begin
11311186 case FController of
1132- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_C;
1133- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_C;
1187+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_C;
1188+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_C;
11341189 end;
11351190 end;
11361191
1137-function TPRI2C.RegisterS: PUInt32;
1192+function TI2C.RegisterS: PUInt32;
11381193 begin
11391194 case FController of
1140- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_S;
1141- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_S;
1195+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_S;
1196+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_S;
11421197 end;
11431198 end;
11441199
1145-function TPRI2C.RegisterDLEN: PUInt32;
1200+function TI2C.RegisterDLEN: PUInt32;
11461201 begin
11471202 case FController of
1148- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DLEN;
1149- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DLEN;
1203+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DLEN;
1204+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DLEN;
11501205 end;
11511206 end;
11521207
1153-function TPRI2C.RegisterA: PUInt32;
1208+function TI2C.RegisterA: PUInt32;
11541209 begin
11551210 case FController of
1156- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_A;
1157- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_A;
1211+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_A;
1212+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_A;
11581213 end;
11591214 end;
11601215
1161-function TPRI2C.RegisterFIFO: PUInt32;
1216+function TI2C.RegisterFIFO: PUInt32;
11621217 begin
11631218 case FController of
1164- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_FIFO;
1165- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_FIFO;
1219+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_FIFO;
1220+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_FIFO;
11661221 end;
11671222 end;
11681223
1169-function TPRI2C.RegisterDIV: PUInt32;
1224+function TI2C.RegisterDIV: PUInt32;
11701225 begin
11711226 case FController of
1172- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DIV;
1173- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DIV;
1227+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DIV;
1228+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DIV;
11741229 end;
11751230 end;
11761231
1177-function TPRI2C.RegisterDEL: PUInt32;
1232+function TI2C.RegisterDEL: PUInt32;
11781233 begin
11791234 case FController of
1180- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DEL;
1181- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DEL;
1235+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_DEL;
1236+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_DEL;
11821237 end;
11831238 end;
11841239
1185-function TPRI2C.RegisterCLKT: PUint32;
1240+function TI2C.RegisterCLKT: PUint32;
11861241 begin
11871242 case FController of
1188- pricBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_CLKT;
1189- pricBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_CLKT;
1243+ icBSC0: Result := FPasRipherals.BSC0BaseAddress + BSC_CLKT;
1244+ icBSC1: Result := FPasRipherals.BSC1BaseAddress + BSC_CLKT;
11901245 end;
11911246 end;
11921247
1193-procedure TPRI2C.SetSlaveAddress(ASalaveAddress: TPRI2CSlaveAddress);
1248+procedure TI2C.SetSlaveAddress(ASalaveAddress: TI2CSlaveAddress);
11941249 begin
11951250 RegisterA^ := ASalaveAddress;
11961251 end;
11971252
1198-function TPRI2C.GetTransferType: TPRI2CTransferType;
1253+function TI2C.GetTransferType: TI2CTransferType;
11991254 begin
1200- Result := TPRI2CTransferType(FPasRipherals.GetBitsValue(RegisterC^,BSC_C_READ,BSC_C_READ_SIZE));
1255+ Result := TI2CTransferType(FPasRipherals.GetBitsValue(RegisterC^,BSC_C_READ,BSC_C_READ_SIZE));
12011256 end;
12021257
1203-function TPRI2C.GetEnabled: Boolean;
1258+function TI2C.GetEnabled: Boolean;
12041259 begin
12051260 Result := FPasRipherals.GetBitsValue(RegisterC^,BSC_C_I2CEN,BSC_C_I2CEN_SIZE).ToBoolean;
12061261 end;
12071262
1208-function TPRI2C.GetTransferActive: Boolean;
1263+function TI2C.GetTransferActive: Boolean;
12091264 begin
12101265 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_TA,BSC_S_TA_SIZE).ToBoolean;
12111266 end;
12121267
1213-function TPRI2C.GetTransferDone: Boolean;
1268+function TI2C.GetTransferDone: Boolean;
12141269 begin
12151270 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_DONE,BSC_S_DONE_SIZE).ToBoolean;
12161271 end;
12171272
1218-function TPRI2C.GetNak: Boolean;
1273+function TI2C.GetNak: Boolean;
12191274 begin
12201275 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_ERR,BSC_S_ERR_SIZE).ToBoolean;
12211276 end;
12221277
1223-function TPRI2C.GetTimeOut:Boolean;
1278+function TI2C.GetTimeOut:Boolean;
12241279 begin
12251280 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_CLKT,BSC_S_CLKT_SIZE).ToBoolean;
12261281 end;
12271282
1228-function TPRI2C.GetDataLength: UInt16;
1283+function TI2C.GetDataLength: UInt16;
12291284 begin
12301285 Result := FPasRipherals.GetBitsValue(RegisterDLEN^,BSC_DLEN_DLEN,BSC_DLEN_DLEN_SIZE);
12311286 end;
12321287
1233-function TPRI2C.GetFIFOContainsData: Boolean;
1288+function TI2C.GetFIFOContainsData: Boolean;
12341289 begin
12351290 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_RXD,BSC_S_RXD_SIZE).ToBoolean;
12361291 end;
12371292
1238-function TPRI2C.GetFIFOCanAcceptData: Boolean;
1293+function TI2C.GetFIFOCanAcceptData: Boolean;
12391294 begin
12401295 Result := FPasRipherals.GetBitsValue(RegisterS^,BSC_S_TXD,BSC_S_TXD_SIZE).ToBoolean;
12411296 end;
12421297
1243-function TPRI2C.GetFIFO: UInt8;
1298+function TI2C.GetFIFO: UInt8;
12441299 begin
12451300 Result := FPasRipherals.GetBitsValue(RegisterFIFO^,BSC_FIFO_DATA,BSC_FIFO_DATA_SIZE);
12461301 end;
12471302
1248-procedure TPRI2C.SetEnabled(AEnabled: Boolean);
1303+procedure TI2C.SetEnabled(AEnabled: Boolean);
12491304 begin
12501305 RegisterC^ := AEnabled.ToInteger shl BSC_C_I2CEN;
12511306 end;
12521307
1253-procedure TPRI2C.SetTransferDone(AResetTransferDoneStatus: Boolean);
1308+procedure TI2C.SetTransferDone(AResetTransferDoneStatus: Boolean);
12541309 begin
12551310 RegisterS^ := AResetTransferDoneStatus.ToInteger shl BSC_S_DONE;
12561311 end;
12571312
1258-procedure TPRI2C.SetNak(AResetNackStatus: Boolean);
1313+procedure TI2C.SetNak(AResetNackStatus: Boolean);
12591314 begin
12601315 RegisterS^ := AResetNackStatus.ToInteger shl BSC_S_ERR;
12611316 end;
12621317
1263-procedure TPRI2C.SetTimeOut(AResetClockStretchStatus: Boolean);
1318+procedure TI2C.SetTimeOut(AResetClockStretchStatus: Boolean);
12641319 begin
12651320 RegisterS^ := AResetClockStretchStatus.ToInteger shl BSC_S_CLKT;
12661321 end;
12671322
1268-procedure TPRI2C.SetDataLength(ADataLength: UInt16);
1323+procedure TI2C.SetDataLength(ADataLength: UInt16);
12691324 begin
12701325 RegisterDLEN^ := ADataLength;
12711326 end;
12721327
1273-procedure TPRI2C.SetFIFO(AValue: UInt8);
1328+procedure TI2C.SetFIFO(AValue: UInt8);
12741329 begin
12751330 RegisterFIFO^ := AValue;
12761331 end;
12771332
1278-procedure TPRI2C.ClearFIFO;
1333+procedure TI2C.ClearFIFO;
12791334 begin
12801335 RegisterC^ := 1 shl BSC_C_CLEAR;
12811336 end;
12821337
1283-procedure TPRI2C.ResetStatus;
1338+procedure TI2C.ResetStatus;
12841339 begin
12851340 RegisterS^ := (1 shl BSC_S_CLKT) or (1 shl BSC_S_ERR) or (1 shl BSC_S_DONE);
12861341 end;
12871342
1288-procedure TPRI2C.StartTransfer(ATransferType: TPRI2CTransferType; AClearFifo: Boolean = False);
1343+procedure TI2C.StartTransfer(ATransferType: TI2CTransferType; AClearFifo: Boolean = False);
12891344 begin
12901345 RegisterC^ := (1 shl BSC_C_I2CEN) or (1 shl BSC_C_ST) or (AClearFifo.ToInteger shl BSC_C_CLEAR) or Byte(ATransferType);
12911346 end;
12921347
1293-function TPRI2C.Read(out ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult;
1348+function TI2C.Read(out ABuffer: PUInt8; ABufferSize: UInt32): TI2CTransferResult;
12941349 var
12951350 RemainingBytes: UInt32;
12961351 begin
@@ -1298,7 +1353,7 @@
12981353 ABuffer := AllocMem(ABufferSize);
12991354
13001355 // Por padrão a função retorna sucesso
1301- Result := pritrSuccess;
1356+ Result := itrSuccess;
13021357
13031358 // Resseta o status
13041359 ResetStatus;
@@ -1307,7 +1362,7 @@
13071362 SetDataLength(ABufferSize);
13081363
13091364 // Limpa o FIFO e inicia o processo de leitura
1310- StartTransfer(prittRead,True);
1365+ StartTransfer(ittRead,True);
13111366
13121367 RemainingBytes := ABufferSize;
13131368
@@ -1337,20 +1392,20 @@
13371392
13381393 // Verifica se houve algum erro, fazendo a função retornar o status correto
13391394 if GetNak then
1340- Result := pritrNak
1395+ Result := itrNak
13411396 else if GetTimeOut then
1342- Result := pritrTimeOut
1397+ Result := itrTimeOut
13431398 else if RemainingBytes > 0 then
1344- Result := pritrInsufficientData;
1399+ Result := itrInsufficientData;
13451400
13461401 // Caso tenha havido algum erro, desaloca a memória alocada para ABuffer
1347- if Result <> pritrSuccess then
1402+ if Result <> itrSuccess then
13481403 FreeMem(ABuffer);
13491404
13501405 SetTransferDone(True);
13511406 end;
13521407
1353-function TPRI2C.Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult;
1408+function TI2C.Read16Bits(out AValue: UInt16; ASwapBytes: Boolean): TI2CTransferResult;
13541409 var
13551410 RB: PUInt8;
13561411 begin
@@ -1357,7 +1412,7 @@
13571412 // Lê 2 bytes (16 bits)
13581413 Result := Read(RB,2);
13591414
1360- if Result = pritrSuccess then
1415+ if Result = itrSuccess then
13611416 try
13621417 AValue := PUInt16(RB)^;
13631418
@@ -1368,16 +1423,16 @@
13681423 end;
13691424 end;
13701425
1371-procedure TPRI2C.Read16Bits(out AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
1426+procedure TI2C.Read16Bits(out AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
13721427 begin
13731428 case Read16Bits(AValue,ASwapBytes) of
1374- pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1375- pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1376- pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1429+ itrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1430+ itrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1431+ itrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
13771432 end;
13781433 end;
13791434
1380-function TPRI2C.Read8Bits(out AValue: UInt8): TPRI2CTransferResult;
1435+function TI2C.Read8Bits(out AValue: UInt8): TI2CTransferResult;
13811436 var
13821437 RB: PUInt8;
13831438 begin
@@ -1384,7 +1439,7 @@
13841439 // Lê 1 byte (8 bits)
13851440 Result := Read(RB,1);
13861441
1387- if Result = pritrSuccess then
1442+ if Result = itrSuccess then
13881443 try
13891444 AValue := PUInt8(RB)^;
13901445 finally
@@ -1392,16 +1447,16 @@
13921447 end;
13931448 end;
13941449
1395-procedure TPRI2C.Read8Bits(out AValue: UInt8; ABaseErrorMessage: String);
1450+procedure TI2C.Read8Bits(out AValue: UInt8; ABaseErrorMessage: String);
13961451 begin
13971452 case Read8Bits(AValue) of
1398- pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1399- pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1400- pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1453+ itrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1454+ itrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1455+ itrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
14011456 end;
14021457 end;
14031458
1404-function TPRI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32): TPRI2CTransferResult;
1459+function TI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32): TI2CTransferResult;
14051460 var
14061461 RemainingBytes: UInt32;
14071462 begin
@@ -1409,7 +1464,7 @@
14091464 raise EPasRipherals.Create('O buffer não foi alocado');
14101465
14111466 // Por padrão a função retorna sucesso
1412- Result := pritrSuccess;
1467+ Result := itrSuccess;
14131468
14141469 // Limpa o buffer FIFO, o qual será preenchido mais adiante com os dados que
14151470 // queremos enviar
@@ -1437,7 +1492,7 @@
14371492 // que acontece em Read16Bits, não está limpando o FIFO porque nós vamos enviar o
14381493 // que há dentro dele (veja o trecho de código anterior) para o dispositivo
14391494 // escravo
1440- StartTransfer(prittWrite);
1495+ StartTransfer(ittWrite);
14411496
14421497 // Enquanto a transferência não tiver sido concluída e ainda houver dados a
14431498 // serem enviados, adiciona 1 Byte ao buffer FIFO. Eu acredito que
@@ -1461,25 +1516,25 @@
14611516
14621517 // Verifica se houve algum erro, fazendo a função retornar o status correto
14631518 if GetNak then
1464- Result := pritrNak
1519+ Result := itrNak
14651520 else if GetTimeOut then
1466- Result := pritrTimeOut
1521+ Result := itrTimeOut
14671522 else if RemainingBytes > 0 then
1468- Result := pritrInsufficientData;
1523+ Result := itrInsufficientData;
14691524
14701525 SetTransferDone(True);
14711526 end;
14721527
1473-procedure TPRI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32; ABaseErrorMessage: String);
1528+procedure TI2C.Write(const ABuffer: PUInt8; ABufferSize: UInt32; ABaseErrorMessage: String);
14741529 begin
14751530 case Write(ABuffer,ABufferSize) of
1476- pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1477- pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1478- pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1531+ itrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1532+ itrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1533+ itrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
14791534 end;
14801535 end;
14811536
1482-function TPRI2C.Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TPRI2CTransferResult;
1537+function TI2C.Write16Bits(AValue: UInt16; ASwapBytes: Boolean): TI2CTransferResult;
14831538 begin
14841539 // Troca a posição dos bytes em AValue.
14851540 if ASwapBytes then
@@ -1489,27 +1544,27 @@
14891544 Result := Write(@AValue,2);
14901545 end;
14911546
1492-procedure TPRI2C.Write16Bits(AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
1547+procedure TI2C.Write16Bits(AValue: UInt16; ABaseErrorMessage: String; ASwapBytes: Boolean);
14931548 begin
14941549 case Write16Bits(AValue,ASwapBytes) of
1495- pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1496- pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1497- pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1550+ itrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1551+ itrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1552+ itrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
14981553 end;
14991554 end;
15001555
1501-function TPRI2C.Write8Bits(AValue: UInt8): TPRI2CTransferResult;
1556+function TI2C.Write8Bits(AValue: UInt8): TI2CTransferResult;
15021557 begin
15031558 // Escreve 1 Byte (8 bits)
15041559 Result := Write(@AValue,1);
15051560 end;
15061561
1507-procedure TPRI2C.Write8Bits(AValue: UInt8; ABaseErrorMessage: String);
1562+procedure TI2C.Write8Bits(AValue: UInt8; ABaseErrorMessage: String);
15081563 begin
15091564 case Write8Bits(AValue) of
1510- pritrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1511- pritrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1512- pritrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
1565+ itrNak: raise EPasRipherals.Create(ABaseErrorMessage + ' : NAK');
1566+ itrInsufficientData: raise EPasRipherals.Create(ABaseErrorMessage + ' : Dados insuficientes');
1567+ itrTimeOut: raise EPasRipherals.Create(ABaseErrorMessage + ' : Tempo esgotado');
15131568 end;
15141569 end;
15151570
@@ -1592,7 +1647,11 @@
15921647
15931648 // Segundo o site https://pinout.xyz/pinout/gpclk, a fórmula do divisor está
15941649 // errada e deveria ser 4096 e não 1024, não sei se isso está correto mas já
1595- // perguntei no forum do raspberry
1650+ // perguntei no forum do raspberry e a resposta levou até o momento a um
1651+ // repositório do git (https://github.com/arisena-com/rpi_src.git) que diz a
1652+ // mesma coisa, mas nos exemplos continuam usando 1024. Será que eu não estou
1653+ // entendendo algo? Eu li algo como se a pessoa tivesse mantido de proposito a
1654+ // formula errada, mas isso não parece fazer sentido
15961655 end;
15971656
15981657 procedure TClock.SetSource(ASource: TClockSource);
@@ -2263,7 +2322,7 @@
22632322 Result.FPWMChannel := APWMChannel;
22642323 end;
22652324
2266-function TCustomPasRipherals.GetI2C(AController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress): TPRI2C;
2325+function TCustomPasRipherals.GetI2C(AController: TI2CController; ASlaveAddress: TI2CSlaveAddress): TI2C;
22672326 begin
22682327 if not FRunningAsRoot then
22692328 raise EPasRipherals.Create('Não é possível acessar o I2C porque você não tem privilégios suficientes');
Show on old repository browser