• R/O
  • SSH
  • HTTPS

pasripherals: Commit


Commit MetaInfo

Revision34 (tree)
Time2019-10-03 12:08:29
Authorderekwildstar

Log Message

Documentação atualizada
Contém erros (não baixe esta revisão)

Change Summary

Incremental Difference

--- trunk/src/lib/UPasRipherals.pas (revision 33)
+++ trunk/src/lib/UPasRipherals.pas (revision 34)
@@ -301,7 +301,7 @@
301301 { TPWM }
302302
303303 (* doc.ok *)
304- //: Este record representa um caal PWM acessado a partir da classe
304+ //: Este record representa um canal PWM acessado a partir da classe
305305 //: TPasRipherals
306306 //: @Member(MarkSpaceEnabled Habilita ou desabilita o modo Mark/Space no canal
307307 //: PWM atual. Quando o modo Mark/Space está desabilitado o canal usa o modo
@@ -322,13 +322,16 @@
322322 FPasRipherals: TCustomPasRipherals;
323323
324324 (* doc.ok *)
325- //: Esta função retorna um ponteiro para o registrador CTL
325+ //: Esta função retorna um ponteiro para o registrador CTL, cujos campos são
326+ //: explicados com detalhes nas páginas 141 a 143 do DataSheet
326327 function RegisterCTL: PUInt32;
327328 (* doc.ok *)
328- //: Esta função retorna um ponteiro para o registrador RNG
329+ //: Esta função retorna um ponteiro para o registrador RNG, cujos campos são
330+ //: explicados com detalhes nas páginas 145 a 146 do DataSheet
329331 function RegisterRNG: PUInt32;
330332 (* doc.ok *)
331- //: Esta função retorna um ponteiro para o registrador DAT
333+ //: Esta função retorna um ponteiro para o registrador DAT, cujos campos são
334+ //: explicados com detalhes nas páginas 146 a 147 do DataSheet
332335 function RegisterDAT: PUInt32;
333336
334337 function GetCurrentConfig: String;
@@ -407,30 +410,39 @@
407410
408411 (* doc.ok *)
409412 //: Esta enumeração representa os possíveis clocks que o RPI possui
410- //: @Value(ciGP0 Use este valor para referir-se ao clock geral 0)
411- //: @Value(ciGP1 Use este valor para referir-se ao clock geral 1)
412- //: @Value(ciGP2 Use este valor para referir-se ao clock geral 2)
413+ //: @Value(ciGP0 Use este valor para referir-se ao clock geral 0 (GPCLK0))
414+ //: @Value(ciGP1 Use este valor para referir-se ao clock geral 1 (GPCLK1).
415+ //: Segundo alguns sites na Internet, este clock não deve ser usado, pois
416+ //: aparentemente ele é o clock da Ethernet)
417+ //: @Value(ciGP2 Use este valor para referir-se ao clock geral 2 (GPCLK2))
413418 //: @Value(ciPCM Use este valor para referir-se ao clock de PCM)
414419 //: @Value(ciPWM Use este valor para referir-se ao clock de PWM)
415420 TClockId = (ciGP0, ciGP1, ciGP2, ciPCM, ciPWM);
416-
417- defina aqui o resto das explicações para os geradores de clock. coloque suas
418- frequencias
419- continue aqui
420-
421+ (* doc.ok *)
421422 //: Esta enumeração representa todas as possíveis fontes de geração de pulsos
422- //: de clock disponíveis no RPI
423+ //: de clock disponíveis no RPI. Nenhuma destas fontes possui referências
424+ //: precisas no DataSheet oficial acerca de suas frequencias nominais, muito
425+ //: menos informações sobre seus usos. Toda informação aqui disponibilizada
426+ //: foi conseguida na Internet e infelizmente não tenho meios de garantir a
427+ //: precisão delas
423428 //: @Value(csGND Não existe gerador de pulso de clock para este valor)
424429 //: @Value(csOscillator Refere-se ao oscilador interno como gerador de pulsos
425- //: de clock)
426- //: @Value(csTestDebug0)
427- //: @Value(csTestDebug1)
428- //: @Value(csPLLA)
429- //: @Value(csPLLC)
430- //: @Value(csPLLD)
431- //: @Value(csHDMIAuxiliary)
432-
433-
430+ //: de clock. A frequência fornecida por esta fonte é de 19.2MHz sempre,
431+ //: independente da existência de um overclock)
432+ //: @Value(csTestDebug0 Refere-se a uma fonte de geração de clock nula (0 Hz))
433+ //: @Value(csTestDebug1 Refere-se a uma fonte de geração de clock nula (0 Hz))
434+ //: @Value(csPLLA Refere-se a uma fonte de geração de clock nula (0 Hz))
435+ //: @Value(csPLLC Refere-se a uma fonte de geração de clock capaz de fornecer
436+ //: 1000 MHz. Este valor varia caso algum overclock esteja em uso, portanto,
437+ //: caso precise usar esta fonte em um RPI com overclock, considere realizar
438+ //: uma medição com um osciloscópio ou multímetro a fim de saber a frequência
439+ //: correta)
440+ //: @Value(csPLLD Refere-se a uma fonte de geração de clock capaz de fornecer
441+ //: 500 MHz. Ao contrário da fonte PLLC, esta fonte não se altera quando o RPI
442+ //: possui um overclock)
443+ //: @Value(csHDMIAuxiliary Refere-se a uma fonte de geração de clock capaz de
444+ //: fornecer 216 MHz. Esta pode não ser uma fonte confiável de frequência
445+ //: estática. Use-a apenas se souber como ela funciona)
434446 //: @Value(csGND8 Não existe gerador de pulso de clock para este valor)
435447 //: @Value(csGND9 Não existe gerador de pulso de clock para este valor)
436448 //: @Value(csGND10 Não existe gerador de pulso de clock para este valor)
@@ -440,7 +452,10 @@
440452 //: @Value(csGND14 Não existe gerador de pulso de clock para este valor)
441453 //: @Value(csGND15 Não existe gerador de pulso de clock para este valor)
442454 TClockSource = (csGND, csOscillator, csTestDebug0, csTestDebug1, csPLLA, csPLLC, csPLLD, csHDMIAuxiliary, csGND8, csGND9, csGND10, csGND11, csGND12, csGND13, csGND14, csGND15);
443- //: Este tipo enumerado define os tipos de "mash" de clocks disponíveis
455+ (* doc.ok *)
456+ //: Este tipo enumerado define os tipos de "mash" de clocks disponíveis A
457+ //: página 105 do DataSheet fala um pouco a respeito do MASH, mas de forma bem
458+ //: superficial.
444459 //: @value(prcmInteger Este valor indica que está sendo usado um divisor
445460 //: inteiro)
446461 //: @value(prcm1Stage Este valor indica que está sendo usado um divisor
@@ -449,17 +464,42 @@
449464 //: fracionário de 2 estágios)
450465 //: @value(prcm3Stage Este valor indica que está sendo usado um divisor
451466 //: fracionário de 3 estágios)
452- TPRClockMash = (prcmInteger, prcm1Stage, prcm2Stage, prcm3Stage);
453- TPRClockDivI = 2..4095;
454- TPRClockDivF = 0..4095;
467+ TClockMash = (cmInteger, cm1Stage, cm2Stage, cm3Stage);
468+ (* doc.ok *)
469+ //: Este tipo define o subconjunto de valores possíveis para a parte inteira
470+ //: do divisor de clock
471+ TClockDivI = 2..4095;
472+ (* doc.ok *)
473+ //: Este tipo define o subconjunto de valores possíveis para a parte
474+ //: fracionária do divisor de clock
475+ TClockDivF = 0..4095;
455476
456- { TPRClock }
477+ { TClock }
457478
458- TPRClock = record
479+ (* doc.ok *)
480+ //: Este record representa um dos clocks acessados a partir da classe
481+ //: TPasRipherals
482+ //: @Member(Source Use esta propriedade para configurar ou obter a fonte de
483+ //: clock utilizada pelo clock atual)
484+ //: @Member(SourceHertz use esta propriedade para obter a frequência em hertz
485+ //: da @Link(Source fonte) de clock atualmente selecionada para o clock atual)
486+ //: @Member(Enabled Use esta propriedade para ativar ou desativar o clock
487+ //: atual
488+ //: @Member(Mash Use esta propriedade para configurar ou obter o valor do
489+ //: @Link(TClockMash "mash") para o clock atual)
490+ //: @Member(DivI Use esta propriedade para configurar ou obter o valor do
491+ //: @Link(TClockDivI divisor inteiro) para o clock atual)
492+ //: @Member(DivF Use esta propriedade para configurar ou obter o valor do
493+ //: @Link(TClockDivF divisor fracionário) para o clock atual)
494+ //: @Member(Divisor Use esta propriedade para obter o valor completo do
495+ //: divisor para o clock atual. Esta propriedade usa a função da página 105 do
496+ //: DataSheet para retornar um número que representa o divisor médio)
497+ TClock = record
459498 private
460499 FClockId: TClockId;
461500 FPasRipherals: TCustomPasRipherals;
462-
501+ continue aqui, descrevendo os dois registerXXXX e melhorando a descrição da
502+ funcao configure mais adiante
463503 function RegisterCTL: PUInt32;
464504 function RegisterDIV: PUInt32;
465505
@@ -466,22 +506,22 @@
466506 function GetSource: TClockSource;
467507 function GetSourceHertz: UInt32;
468508 function GetEnabled: Boolean;
469- function GetMash: TPRClockMash;
470- function GetDivI: TPRClockDivI;
471- function GetDivF: TPRClockDivF;
509+ function GetMash: TClockMash;
510+ function GetDivI: TClockDivI;
511+ function GetDivF: TClockDivF;
472512 function GetDivisor: Double;
473513 procedure SetSource(ASource: TClockSource);
474514 procedure SetEnabled(AEnabled: Boolean);
475- procedure SetMash(AMash: TPRClockMash);
476- procedure SetDivI(ADivI: TPRClockDivI);
477- procedure SetDivF(ADivF: TPRClockDivF);
515+ procedure SetMash(AMash: TClockMash);
516+ procedure SetDivI(ADivI: TClockDivI);
517+ procedure SetDivF(ADivF: TClockDivF);
478518 public
479519 property Source: TClockSource read GetSource write SetSource;
480520 property SourceHertz: UInt32 read GetSourceHertz;
481521 property Enabled: Boolean read GetEnabled write SetEnabled;
482- property Mash: TPRClockMash read GetMash write SetMash;
483- property DivI: TPRClockDivI read GetDivI write SetDivI;
484- property DivF: TPRClockDivF read GetDivF write SetDivF;
522+ property Mash: TClockMash read GetMash write SetMash;
523+ property DivI: TClockDivI read GetDivI write SetDivI;
524+ property DivF: TClockDivF read GetDivF write SetDivF;
485525 property Divisor: Double read GetDivisor;
486526 //: Configura todas as características do clock atual de uma só vez.
487527 //:
@@ -489,7 +529,7 @@
489529 //: suficientemente grande para garantir o funcionamento adequado.
490530 //: Normalmente usar um divisor inteiro e igual a 2 é suficiente. Diminua o
491531 //: clock apenas se for necessário
492- procedure Configure(ASource: TClockSource; AMash: TPRClockMash; ADivI: TPRClockDivI; ADivF: TPRClockDivF; AEnabled: Boolean);
532+ procedure Configure(ASource: TClockSource; AMash: TClockMash; ADivI: TClockDivI; ADivF: TClockDivF; AEnabled: Boolean);
493533 end;
494534
495535 //: Existem 3 controladores BSC principais: BSC0, BSC1 e BSC2. O BSC2 é usado
@@ -860,7 +900,7 @@
860900 FPeripherals: PUInt32;
861901 FRunningAsRoot: Boolean;
862902
863- function GetClock(AClockId: TClockId): TPRClock;
903+ function GetClock(AClockId: TClockId): TClock;
864904 function GetGPIO(AGPIONumber: TGPIONumber): TGPIO;
865905 function GetPWM(APWMChannel: TPWMChannel): TPWM;
866906 function GetI2C(AController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress): TPRI2C;
@@ -895,7 +935,7 @@
895935 //: um registrador de até 32 bits de tamanho
896936 procedure SetBitsValue(ARegister: PUInt32; AValue: UInt32; ABitIndex: UInt8; ABitsCount: UInt8 = 1);
897937
898- property Clock[AClockId: TClockId]: TPRClock read GetClock;
938+ property Clock[AClockId: TClockId]: TClock read GetClock;
899939 property GPIO[AGPIONumber: TGPIONumber]: TGPIO read GetGPIO;
900940 property PWM[APWMChannel: TPWMChannel]: TPWM read GetPWM;
901941 property I2C[AController: TPRI2CController; ASlaveAddress: TPRI2CSlaveAddress]: TPRI2C read GetI2C;
@@ -1473,9 +1513,9 @@
14731513 end;
14741514 end;
14751515
1476-{ TPRClock }
1516+{ TClock }
14771517
1478-function TPRClock.RegisterCTL: PUInt32;
1518+function TClock.RegisterCTL: PUInt32;
14791519 begin
14801520 // Seleciona o registrador correto de acordo com o ID do clock
14811521 case FClockId of
@@ -1487,7 +1527,7 @@
14871527 end;
14881528 end;
14891529
1490-function TPRClock.RegisterDIV: PUInt32;
1530+function TClock.RegisterDIV: PUInt32;
14911531 begin
14921532 // Seleciona o registrador correto de acordo com o ID do clock
14931533 case FClockId of
@@ -1499,13 +1539,13 @@
14991539 end;
15001540 end;
15011541
1502-function TPRClock.GetSource: TClockSource;
1542+function TClock.GetSource: TClockSource;
15031543 begin
15041544 // Bits de 0 a 3 do registrador CTL
15051545 Result := TClockSource(FPasRipherals.GetBitsValue(RegisterCTL^,CLOCK_CTL_SRC,CLOCK_CTL_SRC_SIZE));
15061546 end;
15071547
1508-function TPRClock.GetSourceHertz: UInt32;
1548+function TClock.GetSourceHertz: UInt32;
15091549 begin
15101550 Result := 0;
15111551
@@ -1517,66 +1557,70 @@
15171557 end;
15181558 end;
15191559
1520-function TPRClock.GetEnabled: Boolean;
1560+function TClock.GetEnabled: Boolean;
15211561 begin
15221562 // Bit 4 do registrador CTL
15231563 Result := FPasRipherals.GetBitsValue(RegisterCTL^,CLOCK_CTL_ENAB,CLOCK_CTL_ENAB_SIZE) = 1;
15241564 end;
15251565
1526-function TPRClock.GetMash: TPRClockMash;
1566+function TClock.GetMash: TClockMash;
15271567 begin
15281568 // Bits de 9 a 10 do registrador CTL
1529- Result := TPRClockMash(FPasRipherals.GetBitsValue(RegisterCTL^,CLOCK_CTL_MASH,CLOCK_CTL_MASH_SIZE));
1569+ Result := TClockMash(FPasRipherals.GetBitsValue(RegisterCTL^,CLOCK_CTL_MASH,CLOCK_CTL_MASH_SIZE));
15301570 end;
15311571
1532-function TPRClock.GetDivI: TPRClockDivI;
1572+function TClock.GetDivI: TClockDivI;
15331573 begin
15341574 // Bits 12 a 23 do registrador DIV
15351575 Result := FPasRipherals.GetBitsValue(RegisterDIV^,CLOCK_DIV_DIVI,CLOCK_DIV_DIVI_SIZE);
15361576 end;
15371577
1538-function TPRClock.GetDivF: TPRClockDivF;
1578+function TClock.GetDivF: TClockDivF;
15391579 begin
15401580 // Bits 0 a 11 do registrador DIV
15411581 Result := FPasRipherals.GetBitsValue(RegisterDIV^,CLOCK_DIV_DIVF,CLOCK_DIV_DIVF_SIZE);
15421582 end;
15431583
1544-function TPRClock.GetDivisor: Double;
1584+function TClock.GetDivisor: Double;
15451585 begin
1546- if GetMash = prcmInteger then
1586+ if GetMash = cmInteger then
15471587 Result := GetDivI
15481588 else
15491589 // Usa parte da fórmula da frequencia média existente na página 105 do
15501590 // datasheet, que diz que o divisor médio é (DIVI + DIVF / 1024).
15511591 Result := GetDivI + GetDivF / 1024;
1592+
1593+ // Segundo o site https://pinout.xyz/pinout/gpclk, a fórmula do divisor está
1594+ // errada e deveria ser 4096 e não 1024, não sei se isso está correto mas já
1595+ // perguntei no forum do raspberry
15521596 end;
15531597
1554-procedure TPRClock.SetSource(ASource: TClockSource);
1598+procedure TClock.SetSource(ASource: TClockSource);
15551599 begin
15561600 Configure(ASource,GetMash,GetDivI,GetDivF,GetEnabled);
15571601 end;
15581602
1559-procedure TPRClock.SetEnabled(AEnabled: Boolean);
1603+procedure TClock.SetEnabled(AEnabled: Boolean);
15601604 begin
15611605 Configure(GetSource,GetMash,GetDivI,GetDivF,AEnabled);
15621606 end;
15631607
1564-procedure TPRClock.SetMash(AMash: TPRClockMash);
1608+procedure TClock.SetMash(AMash: TClockMash);
15651609 begin
15661610 Configure(GetSource,AMash,GetDivI,GetDivF,GetEnabled);
15671611 end;
15681612
1569-procedure TPRClock.SetDivI(ADivI: TPRClockDivI);
1613+procedure TClock.SetDivI(ADivI: TClockDivI);
15701614 begin
15711615 Configure(GetSource,GetMash,ADivI,GetDivF,GetEnabled);
15721616 end;
15731617
1574-procedure TPRClock.SetDivF(ADivF: TPRClockDivF);
1618+procedure TClock.SetDivF(ADivF: TClockDivF);
15751619 begin
15761620 Configure(GetSource,GetMash,GetDivI,ADivF,GetEnabled);
15771621 end;
15781622
1579-procedure TPRClock.Configure(ASource: TClockSource; AMash: TPRClockMash; ADivI: TPRClockDivI; ADivF: TPRClockDivF; AEnabled: Boolean);
1623+procedure TClock.Configure(ASource: TClockSource; AMash: TClockMash; ADivI: TClockDivI; ADivF: TClockDivF; AEnabled: Boolean);
15801624 var
15811625 PWMCTLRegister: UInt32;
15821626 begin
@@ -1598,16 +1642,16 @@
15981642 // divisores de acordo com informações colhidas do datasheet e da biblioteca
15991643 // bcm2835. Para mais informações do porquê estou usando esta validação ao
16001644 // invés de confiar no range check que deveria ser imposto pelos tipos
1601- // "TPRClockDivF" e "TPRClockDivI", leia observações no final deste
1645+ // "TClockDivF" e "TClockDivI", leia observações no final deste
16021646 // método.
16031647 case AMash of
1604- prcmInteger, prcm1Stage:
1648+ cmInteger, cm1Stage:
16051649 if (ADivI < 2) or (ADivI > $FFF) then
16061650 raise EPasRipherals.CreateFmt('"%u" não é um valor válido para a parte inteira do divisor de clock. Valores válidos estão entre 2 e 4095',[ADivI]);
1607- prcm2Stage:
1651+ cm2Stage:
16081652 if (ADivI < 3) or (ADivI > $FFF) then
16091653 raise EPasRipherals.CreateFmt('"%u" não é um valor válido para a parte inteira do divisor de clock. Valores válidos estão entre 3 e 4095',[ADivI]);
1610- prcm3Stage:
1654+ cm3Stage:
16111655 if (ADivI < 5) or (ADivI > $FFF) then
16121656 raise EPasRipherals.CreateFmt('"%u" não é um valor válido para a parte inteira do divisor de clock. Valores válidos estão entre 5 e 4095',[ADivI]);
16131657 end;
@@ -1618,7 +1662,7 @@
16181662 // o limite superior do valor. Aqui, caso o Mash seja prcmInteger, estamos
16191663 // zerando ADivF, de forma a simplificar o código mais adiante, o qual sempre
16201664 // vai configurar a parte fracionária do divisor
1621- if AMash <> prcmInteger then
1665+ if AMash <> cmInteger then
16221666 begin
16231667 if ADivF > $FFF then
16241668 raise EPasRipherals.CreateFmt('"%u" não é um valor válido para o a parte fracionária do divisor clock. Valores válidos estão entre 0 e 4095',[ADivF]);
@@ -2082,7 +2126,7 @@
20822126
20832127 { TCustomPasRipherals }
20842128
2085-function TCustomPasRipherals.GetClock(AClockId: TClockId): TPRClock;
2129+function TCustomPasRipherals.GetClock(AClockId: TClockId): TClock;
20862130 begin
20872131 if not FRunningAsRoot then
20882132 raise EPasRipherals.Create('Não é possível acessar o CLOCK porque você não tem privilégios suficientes');
Show on old repository browser