text,length,is_long_context,metric_val,label_metric
"names db 'UNKNOWN' ; 00
db 'AAA ' ; 01
db 'AAD ' ; 02
db 'AAM ' ; 03
db 'AAS ' ; 04
db 'ADC ' ; 05
db 'ADD ' ; 06
db 'AND ' ; 07
db 'CALL ' ; 08
db 'CBW ' ; 09
db 'CLC ' ; 0A
db 'CLD ' ; 0B
db 'CLI ' ; 0C
db 'CMC ' ; 0D
db 'CMP ' ; 0E
db 'CMPSB ' ; 0F
db 'CMPSW ' ; 10
db 'CWD ' ; 11
db 'DAA ' ; 12
db 'DAS ' ; 13
db 'DEC ' ; 14
db 'DIV ' ; 15
db 'ESC ' ; 16
db 'HLT ' ; 17
db 'IDIV ' ; 18
db 'IMUL ' ; 19
db 'IN ' ; 1A
db 'INC ' ; 1B
db 'INT ' ; 1C
db 'INTO ' ; 1D
db 'IRET ' ; 1E
db 'JA ' ; 1F
db 'JB ' ; 20
db 'JCXZ ' ; 21
db 'JE ' ; 22
db 'JG ' ; 23
db 'JL ' ; 24
db 'JMP ' ; 25
db 'JNA ' ; 26
db 'JNB ' ; 27
db 'JNE ' ; 28
db 'JNG ' ; 29
db 'JNL ' ; 2A
db 'JNO ' ; 2B
db 'JNP ' ; 2C
db 'JNS ' ; 2D
db 'JO ' ; 2E
db 'JP ' ; 2F
db 'JS ' ; 30
db 'LAHF ' ; 31
db 'LDS ' ; 32
db 'LEA ' ; 33
db 'LES ' ; 34
db 'LOCK ' ; 35
db 'LODSB ' ; 36
db 'LODSW ' ; 37
db 'LOOP ' ; 38
db 'LOOPE ' ; 39
db 'LOOPNE ' ; 3A
db 'MOV ' ; 3B
db 'MOVSB ' ; 3C
db 'MOVSW ' ; 3D
db 'MUL ' ; 3E
db 'NEG ' ; 3F
db 'NOP ' ; 40
db 'NOT ' ; 41
db 'OR ' ; 42
db 'OUT ' ; 43
db 'POP ' ; 44
db 'POPF ' ; 45
db 'PUSH ' ; 46
db 'PUSHF ' ; 47
db 'RCL ' ; 48
db 'RCR ' ; 49
db 'REP ' ; 4A
db 'REPNE ' ; 4B
db 'RET ' ; 4C
db 'RETF ' ; 4D
db 'RETN ' ; 4E
db 'ROL ' ; 4F
db 'ROR ' ; 50
db 'SAHF ' ; 51
db 'SAR ' ; 52
db 'SBB ' ; 53
db 'SCASB ' ; 54
db 'SCASW ' ; 55
db 'SEGCS ' ; 56
db 'SEGDS ' ; 57
db 'SEGES ' ; 58
db 'SEGSS ' ; 59
db 'SHL ' ; 5A
db 'SHR ' ; 5B
db 'STC ' ; 5C
db 'STD ' ; 5D
db 'STI ' ; 5E
db 'STOSB ' ; 5F
db 'STOSW ' ; 60
db 'SUB ' ; 61
db 'TEST ' ; 62
db 'WAIT ' ; 63
db 'XCHG ' ; 64
db 'XLAT ' ; 65
db 'XOR ' ; 66
; 0 1 2 3 4 5 6 7
regs dw 'AL','CL','DL','BL','AH','CH','DH','BH'
regs2 dw 'AX','CX','DX','BX','SP','BP','SI','DI'
mem db 'BX+SI','BX+DI','BP+SI','BP+DI',0h,0h
mem2 dw 0h,0h,0h,0h,'SI','DI','BP','BX'
regsS dw 'ES' ; 0
dw 'CS' ; 1
dw 'SS' ; 2
dw 'DS' ; 3
farTxt db 'far '
bptr db 'byte ptr '
wptr db 'word ptr '
; Bits composition
; sreg scvw
; sc - subcode, specifies which block of names to look at for rMWN command
; Read functions
rMWR equ 01h ; Read MOD with REG
rMWN equ 02h ; Read MOD with name code
rBIT equ 03h ; Read next command byte as bits
rOFF equ 04h ; Read offset
rILM equ 05h ; Read immediate LSB [MSB]
rALM equ 06h ; Read address ALSB AMSB
; Write functions
wROM equ 10h ; Write r/m
wREG equ 11h ; Write REG
wNAM equ 12h ; Write command name
wCOM equ 13h ; Write comma (,)
wACC equ 14h ; Write accumulator
wIML equ 15h ; Write MSB LSB
wAML equ 16h ; Write [AMSB ALSB]
wIPO equ 17h ; Write IP+offset
wSEG equ 18h ; Write SR
wPRM equ 19h ; Write size ptr r/m
; Special functions
sPRE equ 20h ; Set the prefix for next command
sEXP equ 21h ; Write sign-extended LSB
sSPC equ 22h ; reg = 0: write 1; reg = 1: write AL; reg = 2: write AX; reg = 3: write 3; reg = 4: write ""far""; reg = 5: write CL
sESC equ 23h ; Read next command byte as yyy and then write hex(""reg yyy"")
sIAM equ 24h ; Write MSB LSB:AMSB ALSB
sEXT equ 25h ; Execute extended function
sIPI equ 26h ; Write IP+MSB LSB
sREP equ 27h ; Step into different command using offset as address
outOffset equ 40h
namOffset equ 58h
argOffset equ 60h
emptySpace db 38h DUP(' ')
db 0Ah, 0Dh
functions dw 0h, frMWR, frMWN, frBIT, frOFF, frILM, frALM, 0h, 0h,0h,0h,0h,0h,0h,0h,0h
dw fwROM, fwREG, fwNAM, fwCOM, fwACC, fwIML, fwAML, fwIPO, fwSEG, fwPRM,0h,0h,0h,0h,0h,0h
dw fsPRE, fsEXP, fsSPC, fsESC, fsIAM, fsEXT, fsIPI, fsREP,0h,0h,0h,0h,0h,0h,0h
; 000 001 010 011 100 101 110 111
subNames db 1Bh, 14h, 08h, 08h, 25h, 25h, 46h, 00h ; 0xFE - 0xFF
db 62h, 00h, 41h, 3Fh, 3Eh, 19h, 15h, 18h ; 0xF6 - 0xF7
db 4Fh, 50h, 48h, 49h, 5Ah, 5Bh, 00h, 52h ; 0xD0 - 0xD3
db 06h, 42h, 05h, 53h, 07h, 61h, 66h, 0Eh ; 0x80 - 0x83
; Hex Com Args Size
codes db 06h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 00 ADD r/m, reg Byte
db 06h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 01 ADD r/m, reg Word
db 06h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 02 ADD reg, r/m Byte
db 06h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 03 ADD reg, r/m Word
db 06h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 04 ADD AL, LSB Byte
db 06h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 05 ADD AX, MSB LSB Word
db 46h, rBIT,000h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 06 PUSH ES
db 44h, rBIT,000h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 07 POP ES
db 42h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 08 OR r/m, reg Byte
db 42h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 09 OR r/m, reg Word
db 42h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 0A OR reg, r/m Byte
db 42h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 0B OR reg, r/m Word
db 42h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 0C OR AL, LSB Byte
db 42h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 0D OR AX, MSB LSB Word
db 46h, rBIT,010h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 0E PUSH CS
db 44h, rBIT,010h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 0F POP CS
db 05h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 10 ADC r/m, reg Byte
db 05h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 11 ADC r/m, reg Word
db 05h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 12 ADC reg, r/m Byte
db 05h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 13 ADC reg, r/m Word
db 05h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 14 ADC AL, LSB Byte
db 05h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 15 ADC AX, MSB LSB Word
db 46h, rBIT,020h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 16 PUSH SS
db 44h, rBIT,020h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 17 POP SS
db 53h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 18 SBB r/m, reg Byte
db 53h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 19 SBB r/m, reg Word
db 53h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 1A SBB reg, r/m Byte
db 53h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 1B SBB reg, r/m Word
db 53h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 1C SBB AL, LSB Byte
db 53h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 1D SBB AX, MSB LSB Word
db 46h, rBIT,030h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 1E PUSH DS
db 44h, rBIT,030h,wNAM,wSEG, 0h, 0h, 0h, 0h,0 ; 1F POP DS
db 07h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 20 AND r/m, reg Byte
db 07h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 21 AND r/m, reg Word
db 07h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 22 AND reg, r/m Byte
db 07h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 23 AND reg, r/m Word
db 07h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 24 AND AL, LSB Byte
db 07h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 25 AND AX, MSB LSB Word
db 00h, rBIT,000h,sPRE, 0h, 0h, 0h, 0h, 0h,0 ; 26 Prefix ES
db 12h, wNAM,000h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 27 DAA
db 61h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 28 SUB r/m, reg Byte
db 61h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 29 SUB r/m, reg Word
db 61h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 2A SUB reg, r/m Byte
db 61h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 2B SUB reg, r/m Word
db 61h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 2C SUB AL, LSB Byte
db 61h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 2D SUB AX, MSB LSB Word
db 00h, rBIT,010h,sPRE, 0h, 0h, 0h, 0h, 0h,0 ; 2E Prefix CS
db 13h, wNAM,000h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 2F DAS
db 66h, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 30 XOR r/m, reg Byte
db 66h, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 31 XOR r/m, reg Word
db 66h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 32 XOR reg, r/m Byte
db 66h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 33 XOR reg, r/m Word
db 66h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 34 XOR AL, LSB Byte
db 66h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 35 XOR AX, MSB LSB Word
db 00h, rBIT,020h,sPRE, 0h, 0h, 0h, 0h, 0h,0 ; 36 Prefix SS
db 01h, wNAM,000h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 37 AAA
db 0Eh, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 38 CMP r/m, reg Byte
db 0Eh, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 39 CMP r/m, reg Word
db 0Eh, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 3A CMP reg, r/m Byte
db 0Eh, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 3B CMP reg, r/m Word
db 0Eh, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 3C CMP AL, LSB Byte
db 0Eh, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; 3D CMP AX, MSB LSB Word
db 00h, rBIT,030h,sPRE, 0h, 0h, 0h, 0h, 0h,0 ; 3E Prefix DS
db 04h, wNAM,000h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 3F AAS
db 1Bh, rBIT,001h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 40 INC AX Word
db 1Bh, rBIT,011h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 41 INC CX Word
db 1Bh, rBIT,021h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 42 INC DX Word
db 1Bh, rBIT,031h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 43 INC BX Word
db 1Bh, rBIT,041h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 44 INC SP Word
db 1Bh, rBIT,051h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 45 INC BP Word
db 1Bh, rBIT,061h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 46 INC SI Word
db 1Bh, rBIT,071h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 47 INC DI Word
db 14h, rBIT,001h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 48 DEC AX Word
db 14h, rBIT,011h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 49 DEC CX Word
db 14h, rBIT,021h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4A DEC DX Word
db 14h, rBIT,031h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4B DEC BX Word
db 14h, rBIT,041h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4C DEC SP Word
db 14h, rBIT,051h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4D DEC BP Word
db 14h, rBIT,061h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4E DEC SI Word
db 14h, rBIT,071h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 4F DEC DI Word
db 46h, rBIT,001h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 50 PUSH AX Word
db 46h, rBIT,011h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 51 PUSH CX Word
db 46h, rBIT,021h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 52 PUSH DX Word
db 46h, rBIT,031h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 53 PUSH BX Word
db 46h, rBIT,041h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 54 PUSH SP Word
db 46h, rBIT,051h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 55 PUSH BP Word
db 46h, rBIT,061h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 56 PUSH SI Word
db 46h, rBIT,071h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 57 PUSH DI Word
db 44h, rBIT,001h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 58 POP AX Word
db 44h, rBIT,011h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 59 POP CX Word
db 44h, rBIT,021h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5A POP DX Word
db 44h, rBIT,031h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5B POP BX Word
db 44h, rBIT,041h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5C POP SP Word
db 44h, rBIT,051h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5D POP BP Word
db 44h, rBIT,061h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5E POP SI Word
db 44h, rBIT,071h,wNAM,wREG, 0h, 0h, 0h, 0h,0 ; 5F POP DI Word
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 60 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 61 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 62 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 63 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 64 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 65 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 66 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 67 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 68 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 69 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6A NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6B NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6C NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6D NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6E NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 6F NO COMMAND
db 2Eh, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 70 JO IP+offset
db 2Bh, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 71 JNO IP+offset
db 20h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 72 JB IP+offset
db 27h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 73 JNB IP+offset
db 22h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 74 JE IP+offset
db 28h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 75 JNE IP+offset
db 26h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 76 JNA IP+offset
db 1Fh, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 77 JA IP+offset
db 30h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 78 JS IP+offset
db 2Dh, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 79 JNS IP+offset
db 2Fh, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7A JP IP+offset
db 25h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7B JNP IP+offset
db 24h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7C JL IP+offset
db 2Ah, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7D JNL IP+offset
db 29h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7E JNG IP+offset
db 23h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; 7F JG IP+offset
db 00h, rBIT,00Ch,rMWN,rILM,wNAM,wPRM,wCOM,wIML,0 ; 80 Comm depends on code Byte
db 00h, rBIT,00Dh,rMWN,rILM,wNAM,wPRM,wCOM,wIML,0 ; 81 Comm depends on code Word
db 00h, rBIT,00Ch,rMWN,rILM,wNAM,wPRM,wCOM,wIML,0 ; 82 Comm depends on code Byte
db 00h, rBIT,08Dh,rMWN,rILM,wNAM,wPRM,wCOM,sEXP,0 ; 83 Comm depends on code Word
db 62h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 84 TEST reg, r/m Byte
db 62h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 85 TEST reg, r/m Word
db 64h, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 86 XCHG reg, r/m Byte
db 64h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 87 XCHG reg, r/m Word
db 3Bh, rBIT,000h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 88 MOV r/m, reg Byte
db 3Bh, rBIT,001h,rMWR,wNAM,wROM,wCOM,wREG, 0h,0 ; 89 MOV r/m, reg Word
db 3Bh, rBIT,000h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 8A MOV reg, r/m Byte
db 3Bh, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; 8B MOV reg, r/m Word
db 3Bh, rBIT,001h,rMWR,wNAM,wROM,wCOM,wSEG, 0h,0 ; 8C MOV r/m, SEG
db 33h, rMWR,wNAM,wREG,wCOM,wROM, 0h, 0h, 0h,0 ; 8D LEA reg, r/m
db 3Bh, rMWR,wNAM,wSEG,wCOM,wROM, 0h, 0h, 0h,0 ; 8E MOV SEG, r/m
db 44h, rMWR,wNAM,wROM, 0h, 0h, 0h, 0h, 0h,0 ; 8F POP r/m
db 40h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 90 NOP
db 64h, rBIT,011h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 91 XCHG CX, AX Word
db 64h, rBIT,021h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 92 XCHG DX, AX Word
db 64h, rBIT,031h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 93 XCHG BX, AX Word
db 64h, rBIT,041h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 94 XCHG SP, AX Word
db 64h, rBIT,051h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 95 XCHG BP, AX Word
db 64h, rBIT,061h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 96 XCHG SI, AX Word
db 64h, rBIT,071h,wNAM,wREG,wCOM,wACC, 0h, 0h,0 ; 97 XCHG DI, AX Word
db 09h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 98 CBW
db 11h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 99 CWD
db 08h, rBIT,001h,rALM,rILM,wNAM,sIAM, 0h, 0h,0 ; 9A CALL MSB LSB:AMSB ALSB
db 63h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 9B WAIT
db 47h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 9C PUSHF
db 45h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 9D POPF
db 51h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 9E SAHF
db 31h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; 9F LAHF
db 3Bh, rBIT,000h,rALM,wNAM,wACC,wCOM,wAML, 0h,0 ; A0 MOV AL, AMSB ALSB Byte
db 3Bh, rBIT,001h,rALM,wNAM,wACC,wCOM,wAML, 0h,0 ; A1 MOV AX, AMSB ALSB Word
db 3Bh, rBIT,000h,rALM,wNAM,wAML,wCOM,wACC, 0h,0 ; A2 MOV AMSB ALSB, AL Byte
db 3Bh, rBIT,001h,rALM,wNAM,wAML,wCOM,wACC, 0h,0 ; A3 MOV AMSB ALSB, AX Word
db 3Ch, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; A4 MOVSB
db 3Dh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; A5 MOVSW
db 0Fh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; A6 CMPSB
db 10h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; A7 CMPSW
db 62h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; A8 TEST AL, LSB Byte
db 62h, rBIT,001h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; A9 TEST AX, MSB, LSB Byte
db 5Fh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AA STOSB
db 60h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AB STOSW
db 36h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AC LODSB
db 37h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AD LODSW
db 54h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AE SCASB
db 55h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; AF SCASW
db 3Bh, rBIT,000h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B0 MOV AL, LSB Byte
db 3Bh, rBIT,010h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B1 MOV CL, LSB Byte
db 3Bh, rBIT,020h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B2 MOV DL, LSB Byte
db 3Bh, rBIT,030h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B3 MOV BL, LSB Byte
db 3Bh, rBIT,040h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B4 MOV AH, LSB Byte
db 3Bh, rBIT,050h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B5 MOV CH, LSB Byte
db 3Bh, rBIT,060h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B6 MOV DH, LSB Byte
db 3Bh, rBIT,070h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B7 MOV BH, LSB Byte
db 3Bh, rBIT,001h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B8 MOV AX, MSB LSB Word
db 3Bh, rBIT,011h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; B9 MOV CX, MSB LSB Word
db 3Bh, rBIT,021h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BA MOV DX, MSB LSB Word
db 3Bh, rBIT,031h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BB MOV BX, MSB LSB Word
db 3Bh, rBIT,041h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BC MOV SP, MSB LSB Word
db 3Bh, rBIT,051h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BD MOV BP, MSB LSB Word
db 3Bh, rBIT,061h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BE MOV SI, MSB LSB Word
db 3Bh, rBIT,071h,rILM,wNAM,wREG,wCOM,wIML, 0h,0 ; BF MOV DI, MSB LSB Word
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; C0 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; C1 NO COMMAND
db 4Ch, rBIT,001h,rILM,wNAM,wIML, 0h, 0h, 0h,0 ; C2 RET MSB LSB Word
db 4Ch, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; C3 RET
db 34h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; C4 LES reg, r/m
db 32h, rBIT,001h,rMWR,wNAM,wREG,wCOM,wROM, 0h,0 ; C5 LDS reg, r/m
db 3Bh, rBIT,000h,rMWR,rILM,wNAM,wPRM,wCOM,wIML,0 ; C6 MOV r/m, LSB
db 3Bh, rBIT,001h,rMWR,rILM,wNAM,wPRM,wCOM,wIML,0 ; C7 MOV r/m, MSB LSB
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; C8 NO COMMAND
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; C9 NO COMMAND
db 40h, rBIT,001h,rILM,wNAM,wIML, 0h, 0h, 0h,0 ; CA RETF MSB LSB
db 40h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; CB RETF
db 1Ch, rBIT,030h,wNAM,sSPC, 0h, 0h, 0h, 0h,0 ; CC INT 3
db 1Ch, rBIT,000h,rILM,wNAM,wIML, 0h, 0h, 0h,0 ; CD INT number
db 1Dh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; CE INTO
db 1Eh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; CF IRET
db 00h, rBIT,008h,rMWN,wNAM,wROM,wCOM,sSPC, 0h,0 ; D0 Comm depends on code Byte
db 00h, rBIT,009h,rMWN,wNAM,wROM,wCOM,sSPC, 0h,0 ; D1 Comm depends on code Word
db 00h, rBIT,058h,rMWN,wNAM,wROM,wCOM,sSPC, 0h,0 ; D2 Comm depends on code Byte
db 00h, rBIT,059h,rMWN,wNAM,wROM,wCOM,sSPC, 0h,0 ; D3 Comm depends on code Word
db 03h, rOFF,wNAM, 0h, 0h, 0h, 0h, 0h, 0h,0 ; D4 AAM
db 02h, rOFF,wNAM, 0h, 0h, 0h, 0h, 0h, 0h,0 ; D5 AAD
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; D6 NO COMMAND
db 65h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; D7 XLAT
db 16h, rBIT,000h,rMWR,wNAM,sESC,000h,wCOM,wROM,0 ; D8 ESC hex(000 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,001h,wCOM,wROM,0 ; D9 ESC hex(001 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,002h,wCOM,wROM,0 ; DA ESC hex(010 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,003h,wCOM,wROM,0 ; DB ESC hex(011 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,004h,wCOM,wROM,0 ; DC ESC hex(100 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,005h,wCOM,wROM,0 ; DD ESC hex(101 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,006h,wCOM,wROM,0 ; DE ESC hex(110 yyy), r/m
db 16h, rBIT,000h,rMWR,wNAM,sESC,007h,wCOM,wROM,0 ; DF ESC hex(111 yyy), r/m
db 3Ah, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; E0 LOOPNE IP+offset
db 39h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; E1 LOOPE IP+offset
db 38h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; E2 LOOP IP+offset
db 21h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; E3 JCXZ IP+offset
db 1Ah, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; E4 IN AL, port
db 1Ah, rBIT,020h,rILM,wNAM,sSPC,wCOM,wIML, 0h,0 ; E5 IN AX, port
db 43h, rBIT,000h,rILM,wNAM,wACC,wCOM,wIML, 0h,0 ; E6 OUT AL, port
db 43h, rBIT,020h,rILM,wNAM,sSPC,wCOM,wIML, 0h,0 ; E7 OUT AX, port
db 08h, rBIT,001h,rILM,wNAM,sIPI, 0h, 0h, 0h,0 ; E8 CALL MSB LSB
db 25h, rBIT,001h,rILM,wNAM,sIPI, 0h, 0h, 0h,0 ; E9 JMP MSB LSB
db 25h, rBIT,001h,rALM,rILM,wNAM,sIAM, 0h, 0h,0 ; EA JMP MSB LSB:AMSB ALSB
db 25h, rOFF,wNAM,wIPO, 0h, 0h, 0h, 0h, 0h,0 ; EB JMP IP+offset
db 1Ah, rBIT,000h,wNAM,wACC,wCOM,rBIT,021h,wREG,0 ; EC IN AL, DX
db 1Ah, rBIT,021h,wNAM,wACC,wCOM,wREG, 0h, 0h,0 ; ED IN AX, DX
db 43h, rBIT,000h,wNAM,wACC,wCOM,rBIT,021h,wREG,0 ; EE OUT AL, DX
db 43h, rBIT,021h,wNAM,wACC,wCOM,wREG, 0h, 0h,0 ; EF OUT AX, DX
db 35h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F0 LOCK
db 00h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F1 NO COMMAND
db 4Bh, rOFF,wNAM,sREP,wNAM, 0h, 0h, 0h, 0h,0 ; F2 REPNE
db 4Ah, rOFF,wNAM,sREP,wNAM, 0h, 0h, 0h, 0h,0 ; F3 REP
db 17h, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F4 HLT
db 0Dh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F5 CMC
db 00h, rBIT,004h,rMWN,sEXT, 0h, 0h, 0h, 0h,0 ; F6 Comm depends on code Byte
db 00h, rBIT,005h,rMWN,sEXT, 0h, 0h, 0h, 0h,0 ; F7 Comm depends on code Word
db 0Ah, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F8 CLC
db 5Ch, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; F9 STC
db 0Ch, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; FA CLI
db 5Eh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; FB STI
db 0Bh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; FC CLD
db 5Dh, wNAM, 0h, 0h, 0h, 0h, 0h, 0h, 0h,0 ; FD STD
db 00h, rBIT,000h,rMWN,sEXT, 0h, 0h, 0h, 0h,0 ; FE Comm depends on code Byte
db 00h, rBIT,041h,rMWN,sEXT, 0h, 0h, 0h, 0h,0 ; FF Comm depends on code Word
extCodes db wNAM,wROM, 0h, 0h, 0h,0 ; 000
db wNAM,wROM, 0h, 0h, 0h,0 ; 001
db wNAM,wROM, 0h, 0h, 0h,0 ; 010
db wNAM,sSPC,wROM, 0h, 0h,0 ; 011
db wNAM,wROM, 0h, 0h, 0h,0 ; 100
db wNAM,sSPC,wROM, 0h, 0h,0 ; 101
db wNAM,wROM, 0h, 0h, 0h,0 ; 110
db 0h, 0h, 0h, 0h, 0h,0 ; 111
db rILM,wNAM,wPRM,wCOM,wIML,0 ; 000
db 0h, 0h, 0h, 0h, 0h,0 ; 001
db wNAM,wROM, 0h, 0h, 0h,0 ; 010
db wNAM,wROM, 0h, 0h, 0h,0 ; 011
db wNAM,wROM, 0h, 0h, 0h,0 ; 100
db wNAM,wROM, 0h, 0h, 0h,0 ; 101
db wNAM,wROM, 0h, 0h, 0h,0 ; 110
db wNAM,wROM, 0h, 0h, 0h,0 ; 111
",16241,True,4879.4983050037235,median
"; Copyright © 2020, VideoLAN and dav1d authors
; Copyright © 2020, Two Orioles, LLC
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;
; 1. Redistributions of source code must retain the above copyright notice, this
; list of conditions and the following disclaimer.
;
; 2. Redistributions in binary form must reproduce the above copyright notice,
; this list of conditions and the following disclaimer in the documentation
; and/or other materials provided with the distribution.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
; ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%include ""ext/x86/x86inc.asm""
%if HAVE_AVX512ICL && ARCH_X86_64
%macro DUP4 1-*
%rep %0
times 4 db %1
%rotate 1
%endrep
%endmacro
%macro DIRS 16 ; cdef_directions[]
%rep 4 + 16 + 4 ; 6 7 0 1 2 3 4 5 6 7 0 1
; masking away unused bits allows us to use a single vpaddd {1to16}
; instruction instead of having to do vpbroadcastd + paddb
db %13 & 0x3f, -%13 & 0x3f
%rotate 1
%endrep
%endmacro
SECTION_RODATA 64
lut_perm_4x4: db 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79
db 16, 17, 0, 1, 2, 3, 4, 5, 18, 19, 8, 9, 10, 11, 12, 13
db 20, 21, 80, 81, 82, 83, 84, 85, 22, 23, 32, 33, 34, 35, 36, 37
db 98, 99,100,101,102,103,104,105, 50, 51, 52, 53, 54, 55, 56, 57
lut_perm_4x8a: db 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79
db 96, 97, 0, 1, 2, 3, 4, 5, 98, 99, 8, 9, 10, 11, 12, 13
lut_perm_4x8b:db 100,101, 16, 17, 18, 19, 20, 21,102,103, 24, 25, 26, 27, 28, 29
db 104,105, 32, 33, 34, 35, 36, 37,106,107, 40, 41, 42, 43, 44, 45
db 108,109, 48, 49, 50, 51, 52, 53,110,111, 56, 57, 58, 59, 60, 61
db 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
pd_01234567: dd 0, 1, 2, 3, 4, 5, 6, 7
lut_perm_8x8a: db 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23
db -1, -1, 34, 35, 36, 37, 38, 39, -1, -1, 50, 51, 52, 53, 54, 55
db -1, -1, 66, 67, 68, 69, 70, 71, -1, -1, 82, 83, 84, 85, 86, 87
db 96, 97, 98, 99,100,101,102,103,112,113,114,115,116,117,118,119
lut_perm_8x8b: db 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25, 26, 27
db 36, 37, 38, 39, 40, 41, 42, 43, 52, 53, 54, 55, 56, 57, 58, 59
db 68, 69, 70, 71, 72, 73, 74, 75, 84, 85, 86, 87, 88, 89, 90, 91
db 100,101,102,103,104,105,106,107,116,117,118,119,120,121,122,123
edge_mask: dq 0x00003c3c3c3c0000, 0x00003f3f3f3f0000 ; 0000, 0001
dq 0x0000fcfcfcfc0000, 0x0000ffffffff0000 ; 0010, 0011
dq 0x00003c3c3c3c3c3c, 0x00003f3f3f3f3f3f ; 0100, 0101
dq 0x0000fcfcfcfcfcfc, 0x0000ffffffffffff ; 0110, 0111
dq 0x3c3c3c3c3c3c0000, 0x3f3f3f3f3f3f0000 ; 1000, 1001
dq 0xfcfcfcfcfcfc0000, 0xffffffffffff0000 ; 1010, 1011
dq 0x3c3c3c3c3c3c3c3c, 0x3f3f3f3f3f3f3f3f ; 1100, 1101
dq 0xfcfcfcfcfcfcfcfc, 0xffffffffffffffff ; 1110, 1111
px_idx: DUP4 18, 19, 20, 21, 26, 27, 28, 29, 34, 35, 36, 37, 42, 43, 44, 45
cdef_dirs: DIRS -7,-14, 1, -6, 1, 2, 1, 10, 9, 18, 8, 17, 8, 16, 8, 15
gf_shr: dq 0x0102040810204080, 0x0102040810204080 ; >> 0, >> 0
dq 0x0204081020408000, 0x0408102040800000 ; >> 1, >> 2
dq 0x0810204080000000, 0x1020408000000000 ; >> 3, >> 4
dq 0x2040800000000000, 0x4080000000000000 ; >> 5, >> 6
times 16 db 0 ; realign (introduced by cdef_dirs)
end_perm_w8clip:db 0, 4, 8, 12, 2, 6, 10, 14, 16, 20, 24, 28, 18, 22, 26, 30
db 32, 36, 40, 44, 34, 38, 42, 46, 48, 52, 56, 60, 50, 54, 58, 62
db 1, 5, 9, 13, 3, 7, 11, 15, 17, 21, 25, 29, 19, 23, 27, 31
db 33, 37, 41, 45, 35, 39, 43, 47, 49, 53, 57, 61, 51, 55, 59, 63
end_perm: db 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61
db 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63
pri_tap: db 64, 64, 32, 32, 48, 48, 48, 48 ; left-shifted by 4
sec_tap: db 32, 32, 16, 16
pd_268435568: dd 268435568
SECTION .text
%if WIN64
DECLARE_REG_TMP 5, 6
%else
DECLARE_REG_TMP 8, 5
%endif
; lut:
; t0 t1 t2 t3 t4 t5 t6 t7
; T0 T1 T2 T3 T4 T5 T6 T7
; L0 L1 00 01 02 03 04 05
; L2 L3 10 11 12 13 14 15
; L4 L5 20 21 22 23 24 25
; L6 L7 30 31 32 33 34 35
; 4e 4f 40 41 42 43 44 45
; 5e 5f 50 51 52 53 54 55
INIT_ZMM avx512icl
cglobal cdef_filter_4x4, 4, 8, 13, dst, stride, left, top, pri, sec, dir, damping, edge
%define base r7-edge_mask
movq xmm0, [dstq+strideq*0]
movhps xmm0, [dstq+strideq*1]
lea r7, [edge_mask]
movq xmm1, [topq+strideq*0-2]
movhps xmm1, [topq+strideq*1-2]
mov r6d, edgem
vinserti32x4 ym0, ymm0, [leftq], 1
lea r2, [strideq*3]
vinserti32x4 ym1, ymm1, [dstq+strideq*2], 1
mova m5, [base+lut_perm_4x4]
vinserti32x4 m0, [dstq+r2], 2
test r6b, 0x08 ; avoid buffer overread
jz .main
lea r3, [dstq+strideq*4-4]
vinserti32x4 m1, [r3+strideq*0], 2
vinserti32x4 m0, [r3+strideq*1], 3
.main:
movifnidn prid, prim
mov t0d, dirm
mova m3, [base+px_idx]
mov r3d, dampingm
vpermi2b m5, m0, m1 ; lut
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m7, m7
lea r3, [r7+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m6, m3, m5 ; px
cmp r6d, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m1, m3, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m1, m1, m5 ; k0p0 k0p1 k1p0 k1p1
%macro CDEF_FILTER_4x4_PRI 0
vpcmpub k1, m6, m1, 6 ; px > pN
psubb m2, m1, m6
lzcnt r6d, prid
vpsubb m2{k1}, m6, m1 ; abs(diff)
vpbroadcastb m4, prid
and prid, 1
vgf2p8affineqb m9, m2, [r3+r6*8] {1to8}, 0 ; abs(diff) >> shift
movifnidn t1d, secm
vpbroadcastd m10, [base+pri_tap+priq*4]
vpsubb m10{k1}, m7, m10 ; apply_sign(pri_tap)
psubusb m4, m9 ; imax(0, pri_strength - (abs(diff) >> shift)))
pminub m2, m4
vpdpbusd m0, m2, m10 ; sum
%endmacro
CDEF_FILTER_4x4_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m4, m6, m1
pmaxub m1, m6
pminub m5, m2, m3
pmaxub m2, m3
pminub m4, m5
pmaxub m2, m1
psrldq m1, m4, 2
psrldq m3, m2, 2
pminub m1, m4
vpcmpw k1, m0, m7, 1
vpshldd m6, m0, 8
pmaxub m2, m3
pslldq m3, m1, 1
psubw m7, m0
paddusw m0, m6 ; clip >0xff
vpsubusw m0{k1}, m6, m7 ; clip <0x00
pslldq m4, m2, 1
pminub m1, m3
pmaxub m2, m4
pmaxub m0, m1
pminub m0, m2
jmp .end
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
vpshldd m6, m0, 8 ; (px << 8) + ((sum > -8) << 4)
paddw m0, m6 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
.end:
mova xm1, [base+end_perm]
vpermb m0, m1, m0 ; output in bits 8-15 of each dword
movd [dstq+strideq*0], xm0
pextrd [dstq+strideq*1], xm0, 1
pextrd [dstq+strideq*2], xm0, 2
pextrd [dstq+r2 ], xm0, 3
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
vpbroadcastq m8, [base+edge_mask+r6*8]
test prid, prid
jz .mask_edges_sec_only
vpaddd m2, m3, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m8, m2 ; index in-range
mova m1, m6
vpermb m1{k1}, m2, m5
CDEF_FILTER_4x4_PRI
test t1d, t1d
jz .end_no_clip
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m4, m3, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m9, m3, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m8, m4
mova m2, m6
vpermb m2{k1}, m4, m5
vpshufbitqmb k1, m8, m9
mova m3, m6
vpermb m3{k1}, m9, m5
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m2, m3, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m3, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m2, m2, m5 ; k0s0 k0s1 k1s0 k1s1
vpermb m3, m3, m5 ; k0s2 k0s3 k1s2 k1s3
.sec_main:
vpbroadcastd m8, [base+sec_tap]
vpcmpub k1, m6, m2, 6
psubb m4, m2, m6
vpbroadcastb m12, t1d
lzcnt t1d, t1d
vpsubb m4{k1}, m6, m2
vpcmpub k2, m6, m3, 6
vpbroadcastq m11, [r3+t1*8]
gf2p8affineqb m10, m4, m11, 0
psubb m5, m3, m6
mova m9, m8
vpsubb m8{k1}, m7, m8
psubusb m10, m12, m10
vpsubb m5{k2}, m6, m3
pminub m4, m10
vpdpbusd m0, m4, m8
gf2p8affineqb m11, m5, m11, 0
vpsubb m9{k2}, m7, m9
psubusb m12, m11
pminub m5, m12
vpdpbusd m0, m5, m9
ret
DECLARE_REG_TMP 2, 7
; lut top lut bottom
; t0 t1 t2 t3 t4 t5 t6 t7 L4 L5 20 21 22 23 24 25
; T0 T1 T2 T3 T4 T5 T6 T7 L6 L7 30 31 32 33 34 35
; L0 L1 00 01 02 03 04 05 L8 L9 40 41 42 43 44 45
; L2 L3 10 11 12 13 14 15 La Lb 50 51 52 53 54 55
; L4 L5 20 21 22 23 24 25 Lc Ld 60 61 62 63 64 65
; L6 L7 30 31 32 33 34 35 Le Lf 70 71 72 73 74 75
; L8 L9 40 41 42 43 44 45 8e 8f 80 81 82 83 84 85
; La Lb 50 51 52 53 54 55 9e 9f 90 91 92 93 94 95
cglobal cdef_filter_4x8, 4, 9, 22, dst, stride, left, top, \\
pri, sec, dir, damping, edge
%define base r8-edge_mask
vpbroadcastd ym21, strided
mov r6d, edgem
lea r8, [edge_mask]
movq xm1, [topq+strideq*0-2]
pmulld ym21, [base+pd_01234567]
kxnorb k1, k1, k1
movq xm2, [topq+strideq*1-2]
vpgatherdq m0{k1}, [dstq+ym21] ; +0+1 +2+3 +4+5 +6+7
mova m14, [base+lut_perm_4x8a]
movu m15, [base+lut_perm_4x8b]
test r6b, 0x08 ; avoid buffer overread
jz .main
lea r7, [dstq+strideq*8-2]
vinserti32x4 ym1, [r7+strideq*0], 1
vinserti32x4 ym2, [r7+strideq*1], 1
.main:
punpcklqdq ym1, ym2
vinserti32x4 m1, [leftq], 2 ; -2-1 +8+9 left ____
movifnidn prid, prim
mov t0d, dirm
mova m16, [base+px_idx]
mov r3d, dampingm
vpermi2b m14, m0, m1 ; lut top
vpermi2b m15, m0, m1 ; lut bottom
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m20, m20
lea r3, [r8+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m2, m16, m14 ; pxt
vpermb m3, m16, m15 ; pxb
mova m1, m0
cmp r6b, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m6, m16, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m4, m6, m14 ; pNt k0p0 k0p1 k1p0 k1p1
vpermb m5, m6, m15 ; pNb
%macro CDEF_FILTER_4x8_PRI 0
vpcmpub k1, m2, m4, 6 ; pxt > pNt
vpcmpub k2, m3, m5, 6 ; pxb > pNb
psubb m6, m4, m2
psubb m7, m5, m3
lzcnt r6d, prid
vpsubb m6{k1}, m2, m4 ; abs(diff_top)
vpsubb m7{k2}, m3, m5 ; abs(diff_bottom)
vpbroadcastb m13, prid
vpbroadcastq m9, [r3+r6*8]
and prid, 1
vpbroadcastd m11, [base+pri_tap+priq*4]
vgf2p8affineqb m8, m6, m9, 0 ; abs(dt) >> shift
vgf2p8affineqb m9, m7, m9, 0 ; abs(db) >> shift
mova m10, m11
movifnidn t1d, secm
vpsubb m10{k1}, m20, m11 ; apply_sign(pri_tap_top)
vpsubb m11{k2}, m20, m11 ; apply_sign(pri_tap_bottom)
psubusb m12, m13, m8 ; imax(0, pri_strength - (abs(dt) >> shift)))
psubusb m13, m13, m9 ; imax(0, pri_strength - (abs(db) >> shift)))
pminub m6, m12
pminub m7, m13
vpdpbusd m0, m6, m10 ; sum top
vpdpbusd m1, m7, m11 ; sum bottom
%endmacro
CDEF_FILTER_4x8_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m10, m4, m2
pminub m12, m6, m8
pminub m11, m5, m3
pminub m13, m7, m9
pmaxub m4, m2
pmaxub m6, m8
pmaxub m5, m3
pmaxub m7, m9
pminub m10, m12
pminub m11, m13
pmaxub m4, m6
pmaxub m5, m7
mov r2d, 0xAAAAAAAA
kmovd k1, r2d
kxnorb k2, k2, k2 ; hw lw
vpshrdd m12, m0, m1, 16 ; m1lw m0hw
vpshrdd m6, m10, m11, 16 ; m11lw m10hw
vpshrdd m8, m4, m5, 16 ; m5lw m4hw
vpblendmw m7{k1}, m10, m11 ; m11hw m10lw
vpblendmw m9{k1}, m4, m5 ; m5hw m4lw
vpblendmw m4{k1}, m0, m12 ; m1lw m0lw
vpblendmw m5{k1}, m12, m1 ; m1hw m0hw
vpshrdd m2, m3, 16
pminub m6, m7
pmaxub m8, m9
mova ym14, [base+end_perm]
vpcmpw k1, m4, m20, 1
vpshldw m2, m5, 8
pslldq m7, m6, 1
pslldq m9, m8, 1
psubw m5, m20, m4
paddusw m0, m4, m2 ; clip >0xff
pminub m6, m7
pmaxub m8, m9
psubusw m0{k1}, m2, m5 ; clip <0x00
pmaxub m0, m6
pminub m0, m8
vpermb m0, m14, m0
vpscatterdd [dstq+ym21]{k2}, ym0
RET
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
mova ym4, [base+end_perm]
kxnorb k1, k1, k1
vpshldd m2, m0, 8 ; (px << 8) + ((sum > -8) << 4)
vpshldd m3, m1, 8
paddw m0, m2 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
paddw m1, m3
pslld m0, 16
vpshrdd m0, m1, 16
vpermb m0, m4, m0 ; output in bits 8-15 of each word
vpscatterdd [dstq+ym21]{k1}, ym0
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
mov t1d, r6d
or r6d, 8 ; top 4x4 has bottom
or t1d, 4 ; bottom 4x4 has top
vpbroadcastq m17, [base+edge_mask+r6*8]
vpbroadcastq m18, [base+edge_mask+t1*8]
test prid, prid
jz .mask_edges_sec_only
vpaddd m6, m16, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m17, m6 ; index in-range
vpshufbitqmb k2, m18, m6
mova m4, m2
mova m5, m3
vpermb m4{k1}, m6, m14
vpermb m5{k2}, m6, m15
CDEF_FILTER_4x8_PRI
test t1d, t1d
jz .end_no_clip
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m10, m16, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m11, m16, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m17, m10
vpshufbitqmb k2, m18, m10
vpshufbitqmb k3, m17, m11
vpshufbitqmb k4, m18, m11
mova m6, m2
mova m7, m3
mova m8, m2
mova m9, m3
vpermb m6{k1}, m10, m14
vpermb m7{k2}, m10, m15
vpermb m8{k3}, m11, m14
vpermb m9{k4}, m11, m15
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m8, m16, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m9, m16, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m6, m8, m14 ; pNt k0s0 k0s1 k1s0 k1s1
vpermb m7, m8, m15 ; pNb
vpermb m8, m9, m14 ; pNt k0s2 k0s3 k1s2 k1s3
vpermb m9, m9, m15 ; pNb
.sec_main:
vpbroadcastb m18, t1d
lzcnt t1d, t1d
vpcmpub k1, m2, m6, 6
vpcmpub k2, m3, m7, 6
vpcmpub k3, m2, m8, 6
vpcmpub k4, m3, m9, 6
vpbroadcastq m17, [r3+t1*8]
psubb m10, m6, m2
psubb m11, m7, m3
psubb m12, m8, m2
psubb m13, m9, m3
vpsubb m10{k1}, m2, m6 ; abs(dt0)
vpsubb m11{k2}, m3, m7 ; abs(db0)
vpsubb m12{k3}, m2, m8 ; abs(dt1)
vpsubb m13{k4}, m3, m9 ; abs(db1)
vpbroadcastd m19, [base+sec_tap]
gf2p8affineqb m14, m10, m17, 0 ; abs(dt0) >> shift
gf2p8affineqb m15, m11, m17, 0 ; abs(db0) >> shift
gf2p8affineqb m16, m12, m17, 0 ; abs(dt1) >> shift
gf2p8affineqb m17, m13, m17, 0 ; abs(db1) >> shift
psubusb m14, m18, m14 ; imax(0, sec_strength - (abs(dt0) >> shift)))
psubusb m15, m18, m15 ; imax(0, sec_strength - (abs(db0) >> shift)))
psubusb m16, m18, m16 ; imax(0, sec_strength - (abs(dt1) >> shift)))
psubusb m17, m18, m17 ; imax(0, sec_strength - (abs(db1) >> shift)))
pminub m10, m14
pminub m11, m15
pminub m12, m16
pminub m13, m17
mova m14, m19
mova m15, m19
mova m16, m19
vpsubb m14{k1}, m20, m19 ; apply_sign(sec_tap_top_0)
vpsubb m15{k2}, m20, m19 ; apply_sign(sec_tap_bottom_0)
vpsubb m16{k3}, m20, m19 ; apply_sign(sec_tap_top_1)
vpsubb m19{k4}, m20, m19 ; apply_sign(sec_tap_bottom_1)
vpdpbusd m0, m10, m14
vpdpbusd m1, m11, m15
vpdpbusd m0, m12, m16
vpdpbusd m1, m13, m19
ret
; lut tl lut tr
; t0 t1 t2 t3 t4 t5 t6 t7 t6 t7 t8 t9 ta tb tc td
; T0 T1 T2 T3 T4 T5 T6 T7 T6 T7 T8 T9 TA TB TC TD
; L0 L1 00 01 02 03 04 05 04 05 06 07 08 09 0a 0b
; L2 L3 10 11 12 13 14 15 14 15 16 17 18 19 1a 1b
; L4 L5 20 21 22 23 24 25 24 25 26 27 28 29 2a 2b
; L6 L7 30 31 32 33 34 35 34 35 36 37 38 39 3a 3b
; L8 L9 40 41 42 43 44 45 44 45 46 47 48 49 4a 4b
; La Lb 50 51 52 53 54 55 54 55 56 57 58 59 5a 5b
; lut bl lut br
; L4 L5 20 21 22 23 24 25 24 25 26 27 28 29 2a 2b
; L6 L7 30 31 32 33 34 35 34 35 36 37 38 39 3a 3b
; L8 L9 40 41 42 43 44 45 44 45 46 47 48 49 4a 4b
; La Lb 50 51 52 53 54 55 54 55 56 57 58 59 5a 5b
; Lc Ld 60 61 62 63 64 65 64 65 66 67 68 69 6a 6b
; Le Lf 70 71 72 73 74 75 74 75 76 77 78 79 7a 7b
; 8e 8f 80 81 82 83 84 85 84 85 86 87 88 89 8a 8b
; 9e 9f 90 91 92 93 94 95 94 95 96 97 98 99 9a 9b
cglobal cdef_filter_8x8, 4, 11, 32, 4*64, dst, stride, left, top, \\
pri, sec, dir, damping, edge
%define base r8-edge_mask
mov r6d, edgem
lea r10, [dstq+strideq*4-2]
movu xmm0, [topq+strideq*0-2]
movu xmm1, [dstq+strideq*2-2]
movu xmm2, [r10 +strideq*2 ]
lea r8, [edge_mask]
lea r9, [strideq*3]
pmovzxwq m10, [leftq-4]
vinserti32x4 ym0, ymm0, [topq+strideq*1-2], 1
vinserti32x4 ym1, ymm1, [dstq+r9 -2], 1
vinserti32x4 ym2, ymm2, [r10 +r9 ], 1
lea r7, [r10 +strideq*4 ]
pmovzxwq m11, [leftq+4]
vinserti32x4 m0, [dstq+strideq*0-2], 2
vinserti32x4 m1, [r10 +strideq*0 ], 2
mova m12, [base+lut_perm_8x8a]
movu m13, [base+lut_perm_8x8b]
vinserti32x4 m0, [dstq+strideq*1-2], 3
vinserti32x4 m1, [r10 +strideq*1 ], 3
test r6b, 0x08 ; avoid buffer overread
jz .main
vinserti32x4 m2, [r7 +strideq*0], 2
vinserti32x4 m2, [r7 +strideq*1], 3
.main:
mov t1d, 0x11111100
mova m14, m12
mova m15, m13
kmovd k1, t1d
kshiftrd k2, k1, 8
movifnidn prid, prim
mov t0d, dirm
mova m30, [base+px_idx]
mov r3d, dampingm
vpermi2b m12, m0, m1 ; lut tl
vpermi2b m14, m1, m2 ; lut bl
vpermi2b m13, m0, m1 ; lut tr
vpermi2b m15, m1, m2 ; lut br
vpblendmw m12{k1}, m12, m10
vpblendmw m14{k2}, m14, m11
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m31, m31
lea r3, [r8+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m4, m30, m12 ; pxtl
vpermb m5, m30, m13 ; pxtr
vpermb m6, m30, m14 ; pxbl
vpermb m7, m30, m15 ; pxbr
mova m1, m0
mova m2, m0
mova m3, m0
cmp r6b, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m11, m30, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m8, m11, m12 ; pNtl k0p0 k0p1 k1p0 k1p1
vpermb m9, m11, m13 ; pNtr
vpermb m10, m11, m14 ; pNbl
vpermb m11, m11, m15 ; pNbr
%macro CDEF_FILTER_8x8_PRI 0
vpcmpub k1, m4, m8, 6 ; pxtl > pNtl
vpcmpub k2, m5, m9, 6 ; pxtr > pNtr
vpcmpub k3, m6, m10, 6 ; pxbl > pNbl
vpcmpub k4, m7, m11, 6 ; pxbr > pNbr
psubb m16, m8, m4
psubb m17, m9, m5
psubb m18, m10, m6
psubb m19, m11, m7
lzcnt r6d, prid
vpsubb m16{k1}, m4, m8 ; abs(diff_tl)
vpsubb m17{k2}, m5, m9 ; abs(diff_tr)
vpsubb m18{k3}, m6, m10 ; abs(diff_bl)
vpsubb m19{k4}, m7, m11 ; abs(diff_br)
vpbroadcastq m28, [r3+r6*8]
vpbroadcastb m29, prid
and prid, 1
vpbroadcastd m27, [base+pri_tap+priq*4]
vgf2p8affineqb m20, m16, m28, 0 ; abs(dtl) >> shift
vgf2p8affineqb m21, m17, m28, 0 ; abs(dtr) >> shift
vgf2p8affineqb m22, m18, m28, 0 ; abs(dbl) >> shift
vgf2p8affineqb m23, m19, m28, 0 ; abs(dbl) >> shift
mova m24, m27
mova m25, m27
mova m26, m27
movifnidn t1d, secm
vpsubb m24{k1}, m31, m27 ; apply_sign(pri_tap_tl)
vpsubb m25{k2}, m31, m27 ; apply_sign(pri_tap_tr)
vpsubb m26{k3}, m31, m27 ; apply_sign(pri_tap_tl)
vpsubb m27{k4}, m31, m27 ; apply_sign(pri_tap_tr)
psubusb m20, m29, m20 ; imax(0, pri_strength - (abs(dtl) >> shift)))
psubusb m21, m29, m21 ; imax(0, pri_strength - (abs(dtr) >> shift)))
psubusb m22, m29, m22 ; imax(0, pri_strength - (abs(dbl) >> shift)))
psubusb m23, m29, m23 ; imax(0, pri_strength - (abs(dbr) >> shift)))
pminub m16, m20
pminub m17, m21
pminub m18, m22
pminub m19, m23
vpdpbusd m0, m16, m24 ; sum tl
vpdpbusd m1, m17, m25 ; sum tr
vpdpbusd m2, m18, m26 ; sum bl
vpdpbusd m3, m19, m27 ; sum br
%endmacro
CDEF_FILTER_8x8_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m20, m8, m4
pminub m24, m12, m16
pminub m21, m9, m5
pminub m25, m13, m17
pminub m22, m10, m6
pminub m26, m14, m18
pminub m23, m11, m7
pminub m27, m15, m19
pmaxub m8, m4
pmaxub m12, m16
pmaxub m9, m5
pmaxub m13, m17
pmaxub m10, m6
pmaxub m14, m18
pmaxub m11, m7
pmaxub m15, m19
pminub m20, m24
pminub m21, m25
pminub m22, m26
pminub m23, m27
pmaxub m8, m12
pmaxub m9, m13
pmaxub m10, m14
pmaxub m11, m15
mov r2d, 0xAAAAAAAA
kmovd k1, r2d
vpshrdd m24, m0, m1, 16
vpshrdd m25, m2, m3, 16
vpshrdd m12, m20, m21, 16
vpshrdd m14, m22, m23, 16
vpshrdd m16, m8, m9, 16
vpshrdd m18, m10, m11, 16
vpblendmw m13{k1}, m20, m21
vpblendmw m15{k1}, m22, m23
vpblendmw m17{k1}, m8, m9
vpblendmw m19{k1}, m10, m11
vpblendmw m20{k1}, m0, m24
vpblendmw m21{k1}, m24, m1
vpblendmw m22{k1}, m2, m25
vpblendmw m23{k1}, m25, m3
vpshrdd m4, m5, 16
vpshrdd m6, m7, 16
pminub m12, m13
pminub m14, m15
pmaxub m16, m17
pmaxub m18, m19
mova m8, [base+end_perm_w8clip]
vpcmpw k2, m20, m31, 1
vpcmpw k3, m22, m31, 1
vpshldw m4, m21, 8
vpshldw m6, m23, 8
kunpckdq k1, k1, k1
kxnorb k4, k4, k4
vpshrdw m11, m12, m14, 8
vpshrdw m15, m16, m18, 8
vpblendmb m13{k1}, m12, m14
vpblendmb m17{k1}, m16, m18
psubw m21, m31, m20
psubw m23, m31, m22
paddusw m0, m20, m4 ; clip >0xff
paddusw m1, m22, m6
pminub m11, m13
pmaxub m15, m17
psubusw m0{k2}, m4, m21 ; clip <0x00
psubusw m1{k3}, m6, m23
psrlw m0, 8
vmovdqu8 m0{k1}, m1
pmaxub m0, m11
pminub m0, m15
vpermb m0, m8, m0
add r10, 2
vextracti32x4 xm1, m0, 1
vextracti32x4 xm2, m0, 2
vextracti32x4 xm3, m0, 3
movq [dstq+strideq*0], xm0
movq [dstq+strideq*2], xm1
movq [r10 +strideq*0], xm2
movq [r10 +strideq*2], xm3
movhps [dstq+strideq*1], xm0
movhps [dstq+r9 ], xm1
movhps [r10 +strideq*1], xm2
movhps [r10 +r9 ], xm3
RET
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
mova xm8, [base+end_perm]
kxnorb k1, k1, k1
vpshldd m4, m0, 8 ; (px << 8) + ((sum > -8) << 4)
vpshldd m5, m1, 8
vpshldd m6, m2, 8
vpshldd m7, m3, 8
paddw m0, m4 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
paddw m1, m5
paddw m2, m6
paddw m3, m7
vpermb m0, m8, m0
vpermb m1, m8, m1
vpermb m2, m8, m2
vpermb m3, m8, m3
add r10, 2
punpckldq m4, m0, m1
punpckhdq m0, m1
punpckldq m5, m2, m3
punpckhdq m2, m3
movq [dstq+strideq*0], xm4
movq [dstq+strideq*2], xm0
movq [r10 +strideq*0], xm5
movq [r10 +strideq*2], xm2
movhps [dstq+strideq*1], xm4
movhps [dstq+r9 ], xm0
movhps [r10 +strideq*1], xm5
movhps [r10 +r9 ], xm2
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
mov t0d, r6d
mov t1d, r6d
or t0d, 0xA ; top-left 4x4 has bottom and right
or t1d, 0x9 ; top-right 4x4 has bottom and left
vpbroadcastq m26, [base+edge_mask+t0*8]
vpbroadcastq m27, [base+edge_mask+t1*8]
mov t1d, r6d
or r6d, 0x6 ; bottom-left 4x4 has top and right
or t1d, 0x5 ; bottom-right 4x4 has top and left
vpbroadcastq m28, [base+edge_mask+r6*8]
vpbroadcastq m29, [base+edge_mask+t1*8]
mov t0d, dirm
test prid, prid
jz .mask_edges_sec_only
vpaddd m20, m30, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m26, m20 ; index in-range
vpshufbitqmb k2, m27, m20
vpshufbitqmb k3, m28, m20
vpshufbitqmb k4, m29, m20
mova m8, m4
mova m9, m5
mova m10, m6
mova m11, m7
vpermb m8{k1}, m20, m12
vpermb m9{k2}, m20, m13
vpermb m10{k3}, m20, m14
vpermb m11{k4}, m20, m15
mova [rsp+0x00], m26
mova [rsp+0x40], m27
mova [rsp+0x80], m28
mova [rsp+0xC0], m29
CDEF_FILTER_8x8_PRI
test t1d, t1d
jz .end_no_clip
mova m26, [rsp+0x00]
mova m27, [rsp+0x40]
mova m28, [rsp+0x80]
mova m29, [rsp+0xC0]
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m20, m30, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m21, m30, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m26, m20
vpshufbitqmb k2, m27, m20
vpshufbitqmb k3, m28, m20
vpshufbitqmb k4, m29, m20
mova m16, m4
mova m17, m5
mova m18, m6
mova m19, m7
vpermb m16{k1}, m20, m12
vpermb m17{k2}, m20, m13
vpermb m18{k3}, m20, m14
vpermb m19{k4}, m20, m15
vpshufbitqmb k1, m26, m21
vpshufbitqmb k2, m27, m21
vpshufbitqmb k3, m28, m21
vpshufbitqmb k4, m29, m21
vpermb m12, m21, m12
vpermb m13, m21, m13
vpermb m14, m21, m14
vpermb m15, m21, m15
vpblendmb m12{k1}, m4, m12
vpblendmb m13{k2}, m5, m13
vpblendmb m14{k3}, m6, m14
vpblendmb m15{k4}, m7, m15
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m20, m30, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m21, m30, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m16, m20, m12 ; pNtl k0s0 k0s1 k1s0 k1s1
vpermb m17, m20, m13 ; pNtr
vpermb m18, m20, m14 ; pNbl
vpermb m19, m20, m15 ; pNbr
vpermb m12, m21, m12 ; pNtl k0s2 k0s3 k1s2 k1s3
vpermb m13, m21, m13 ; pNtr
vpermb m14, m21, m14 ; pNbl
vpermb m15, m21, m15 ; pNbr
.sec_main:
%macro CDEF_FILTER_8x8_SEC 4-5 0 ; load constants
vpcmpub k1, m4, %1, 6
vpcmpub k2, m5, %2, 6
vpcmpub k3, m6, %3, 6
vpcmpub k4, m7, %4, 6
psubb m20, %1, m4
psubb m21, %2, m5
psubb m22, %3, m6
psubb m23, %4, m7
%if %5
vpbroadcastb m28, t1d
lzcnt t1d, t1d
vpbroadcastq m29, [r3+t1*8]
%endif
vpsubb m20{k1}, m4, %1
vpsubb m21{k2}, m5, %2
vpsubb m22{k3}, m6, %3
vpsubb m23{k4}, m7, %4
gf2p8affineqb m24, m20, m29, 0
gf2p8affineqb m25, m21, m29, 0
gf2p8affineqb m26, m22, m29, 0
gf2p8affineqb m27, m23, m29, 0
%if %5
vpbroadcastd m30, [base+sec_tap]
%endif
psubusb m24, m28, m24
psubusb m25, m28, m25
psubusb m26, m28, m26
psubusb m27, m28, m27
pminub m20, m24
pminub m21, m25
pminub m22, m26
pminub m23, m27
mova m24, m30
mova m25, m30
mova m26, m30
mova m27, m30
vpsubb m24{k1}, m31, m30
vpsubb m25{k2}, m31, m30
vpsubb m26{k3}, m31, m30
vpsubb m27{k4}, m31, m30
vpdpbusd m0, m20, m24
vpdpbusd m1, m21, m25
vpdpbusd m2, m22, m26
vpdpbusd m3, m23, m27
%endmacro
CDEF_FILTER_8x8_SEC m16, m17, m18, m19, 1
CDEF_FILTER_8x8_SEC m12, m13, m14, m15
ret
%endif ; HAVE_AVX512ICL && ARCH_X86_64
",16297,True,3532.1696277931064,median
";,; lyrics_itwillleadus .withinpagefrom=lyrics
;,; <- lyrics
!byte $21,$29,$1d ; IT
!byte $07 ; 'LL
!byte $51,$19,$1d ; (L)EAD ; was 71
!byte $3a,$34 ; US
!byte $59,$1d,$46 ; TO ; was 49
!byte $4a,$46,$40,$89 ; OUR ; was 09
!byte $1b,$2a,$40 ; PRO
!byte $28,$41,$24,$19,$1d ; MISED
!byte $39,$43,$51 ; (H)A
!byte $26,$63,$62 ; VEN
!byte $0f
;,; deps_itwilllead
;,; <- lyrics_itwillleadus
;,; <- ibpcaablocks
;,; SC31_000a
;,; <- deps_itwilllead
;,; <- streamvars
;,; <- lyrics_itwillleadus
;,; <- player_ivars
!src ""demosrc/smac.inc""
+sAddr nextlyrictosing
!byte $00,lyrics_itwillleadus-lyrics
; method 4 ( clrscr bytes ) -- 462 bytes (462 cumu)
; method 5 ( clrscr ibpc0 bytes ) -- 493 bytes (493 cumu)
; method 6 ( clrscr bytes ) -- 462 bytes (462 cumu)
; method 7 ( clrscr ibpc0 ibpcaa bytes ) -- 518 bytes (518 cumu)
; METHOD 4 CHOSEN
!byte $e4,3,ch0000000000000000 ; clrscr
; total unique chars in pic: 46 (worst case req 368 bytes)
!byte $DA,$00 ;addr
!byte $54,$02 ;fill
!byte $e2,1;mode4
!byte $01 ;data4
!byte $66
!byte $22
!byte $52,$01 ;fill
!byte $01 ;data4
!byte $66
!byte $22
!byte $52,$01 ;fill
!byte $00 ;data4
!byte $66
!byte $4F,$02 ;fill
!byte $07 ;data4
!byte $44
!byte $64
!byte $66
!byte $26
!byte $22
!byte $22
!byte $12
!byte $33
!byte $46,$02 ;fill
!byte $0B ;data4
!byte $44
!byte $44
!byte $64
!byte $26
!byte $22
!byte $22
!byte $12
!byte $33
!byte $33
!byte $22
!byte $22
!byte $22
!byte $45,$04 ;fill
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $22
!byte $22
!byte $22
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $55
!byte $55
!byte $55
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $55
!byte $55
!byte $55
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $55
!byte $55
!byte $55
!byte $31
!byte $8F ;skip
!byte $03 ;data4
!byte $55
!byte $55
!byte $55
!byte $31
!byte $8F ;skip
!byte $59,$05 ;fill
!byte $50,$01 ;fill
!byte $02 ;data4
!byte $55
!byte $55
!byte $55
!byte $50,$01 ;fill
!byte $58,$05 ;fill
!byte $00 ;data4
!byte $0B
!byte $e1,3
;,; *_000b
;,; <- deps_itwilllead
;,; <- streamvars
;,; <- lyrics_itwillleadus
;,; <- player_ivars
;,; <- chFFFFFFFFFFFFFFFF ; 88
;,; <- ch0000000000000000 ; 178
;,; <- chFCFC303030303030 ; 5
;,; <- chC6C6C6C6C6C6C6C6 ; 2
;,; <- chC0C0C0C0C0C0C0C0 ; 3
;,; <- chFCFCE0C0C0C0C0C0 ; 6
;,; <- chFCFCDCCCCCCCCCCC ; 12
;,; <- chF0F8CCCCCCCCCCCC ; 4
;,; <- chCCCCCCCCCCCCCCCC ; 5
;,; <- chFEFEFEFCFEFCFCF8 ; 2
;,; <- chFF7F7F3F7F3F3F1F ; 3
;,; <- ch303030303030FCFC ; 3
;,; <- ch3030303030303030 ; 2
;,; <- chD6D6D6D6D6F6FEFE ; 1
;,; <- chC0C0C0C0C0E0FCFC ; 3
;,; <- chFCFCE0C0C0E0FCFC ; 3
;,; <- chCCCCCCCCCCECFCFC ; 7
;,; <- chFCFC1C0C0C1CFCFC ; 2
;,; <- chFEFEFCFCF8F8F0E0 ; 6
;,; <- ch7F7F3F3F1F1F0F07 ; 7
;,; <- chF8F8F0F0E0E0C080 ; 7
;,; <- ch1F1F0F0F07070301 ; 5
;,; <- chC0F0FCFFFFFFFFFF ; 7
;,; <- ch00000000C0F0FCFF ; 7
;,; <- ch7F3F1F0F07030100 ; 4
;,; <- chF0E0C08000000000 ; 4
;,; <- ch000000000103070F ; 5
;,; <- chFFFFFFFFFEFEFEFE ; 5
;,; <- ch0008080800000000 ; 4
;,; <- ch1F1F1F1F1F1F1F1F ; 6
;,; <- chFEFEFEFEFFFFFFFF ; 5
;,; <- ch00000000C0E0F0F0 ; 5
;,; <- ch4002001000044100 ; 11
;,; <- ch5002148128004210 ; 9
;,; <- ch1F3F7FFFFFFF7F3F ; 6
;,; <- chC0C0C0E0E1E0E0E0 ; 5
;,; <- chF05A2CC52A554ABD ; 13
;,; <- ch3F3F3F3F3F3F3F3F ; 12
;,; <- chE0C0800000000000 ; 5
;,; <- ch80C0E0F0F8F8F8F8 ; 5
;,; <- ch7F7F7F7F7F7F7F7F ; 6
;,; <- chF8F8F8F8C0C0C0C0 ; 5
;,; <- chFFFFFFFFFFFF0000 ; 18
;,; <- chFEFEDED6D6D6D6D6 ; 1
;,; <- chCCCCCCCC78783030 ; 1
;,; <- ch5555555555555555 ; 1
!byte $CE,$00 ;addr
!byte $e2,0;mode8
!byte $01 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte $93 ;skip
!byte $42,chFFFFFFFFFFFFFFFF ;fill
!byte $2F ;data8
!byte ch0000000000000000
!byte chFCFC303030303030
!byte chFCFC303030303030
!byte ch0000000000000000
!byte chC6C6C6C6C6C6C6C6
!byte chFCFC303030303030
!byte chC0C0C0C0C0C0C0C0
!byte chC0C0C0C0C0C0C0C0
!byte ch0000000000000000
!byte chC0C0C0C0C0C0C0C0
!byte chFCFCE0C0C0C0C0C0
!byte chFCFCDCCCCCCCCCCC
!byte chF0F8CCCCCCCCCCCC
!byte ch0000000000000000
!byte chCCCCCCCCCCCCCCCC
!byte chFCFCE0C0C0C0C0C0
!byte ch0000000000000000
!byte chFCFC303030303030
!byte chFCFCDCCCCCCCCCCC
!byte ch0000000000000000
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chFEFEFEFCFEFCFCF8
!byte chFF7F7F3F7F3F3F1F
!byte ch0000000000000000
!byte ch303030303030FCFC
!byte ch3030303030303030
!byte ch0000000000000000
!byte chD6D6D6D6D6F6FEFE
!byte ch303030303030FCFC
!byte chC0C0C0C0C0E0FCFC
!byte chC0C0C0C0C0E0FCFC
!byte ch0000000000000000
!byte chC0C0C0C0C0E0FCFC
!byte chFCFCE0C0C0E0FCFC
!byte chFCFCDCCCCCCCCCCC
!byte chCCCCCCCCCCECFCFC
!byte ch0000000000000000
!byte chCCCCCCCCCCECFCFC
!byte chFCFC1C0C0C1CFCFC
!byte ch0000000000000000
!byte ch3030303030303030
!byte chCCCCCCCCCCECFCFC
!byte ch0000000000000000
!byte chFEFEFEFCFEFCFCF8
!byte chFF7F7F3F7F3F3F1F
!byte chFEFEFCFCF8F8F0E0
!byte ch7F7F3F3F1F1F0F07
!byte $93 ;skip
!byte $19 ;data8
!byte chFEFEFCFCF8F8F0E0
!byte chFF7F7F3F7F3F3F1F
!byte chF8F8F0F0E0E0C080
!byte ch1F1F0F0F07070301
!byte chF8F8F0F0E0E0C080
!byte ch0000000000000000
!byte ch0000000000000000
!byte ch0000000000000000
!byte chFFFFFFFFFFFFFFFF
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte ch0000000000000000
!byte ch7F7F3F3F1F1F0F07
!byte chFFFFFFFFFFFFFFFF
!byte chFEFEFCFCF8F8F0E0
!byte ch7F7F3F3F1F1F0F07
!byte chF8F8F0F0E0E0C080
!byte ch1F1F0F0F07070301
!byte chFEFEFCFCF8F8F0E0
!byte ch7F7F3F3F1F1F0F07
!byte chFEFEFCFCF8F8F0E0
!byte ch7F7F3F3F1F1F0F07
!byte chFEFEFCFCF8F8F0E0
!byte ch7F7F3F3F1F1F0F07
!byte chF8F8F0F0E0E0C080
!byte ch7F7F3F3F1F1F0F07
!byte $85 ;skip
!byte $06 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte ch1F1F0F0F07070301
!byte chF8F8F0F0E0E0C080
!byte $83 ;skip
!byte $03 ;data8
!byte ch1F1F0F0F07070301
!byte chF8F8F0F0E0E0C080
!byte ch1F1F0F0F07070301
!byte chF8F8F0F0E0E0C080
!byte $88 ;skip
!byte $43,chFFFFFFFFFFFFFFFF ;fill
!byte $01 ;data8
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte $90 ;skip
!byte $45,chFFFFFFFFFFFFFFFF ;fill
!byte $01 ;data8
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte $8E ;skip
!byte $47,chFFFFFFFFFFFFFFFF ;fill
!byte $01 ;data8
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte $8C ;skip
!byte $49,chFFFFFFFFFFFFFFFF ;fill
!byte $01 ;data8
!byte chC0F0FCFFFFFFFFFF
!byte ch00000000C0F0FCFF
!byte $8A ;skip
!byte $0E ;data8
!byte chFFFFFFFFFFFFFFFF
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch0000000000000000
!byte ch00000000C0F0FCFF
!byte $88 ;skip
!byte $0E ;data8
!byte chFFFFFFFFFFFFFFFF
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte $88 ;skip
!byte $3F ;data8
!byte chFFFFFFFFFFFFFFFF
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chC0F0FCFFFFFFFFFF
!byte ch0000000000000000
!byte ch4002001000044100
!byte ch4002001000044100
!byte ch4002001000044100
!byte ch5002148128004210
!byte ch5002148128004210
!byte chFFFFFFFFFFFFFFFF
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch4002001000044100
!byte ch4002001000044100
!byte ch5002148128004210
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte chFFFFFFFFFFFFFFFF
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte $1C ;data8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch4002001000044100
!byte ch5002148128004210
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch5002148128004210
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte $42,chFFFFFFFFFFFFFFFF ;fill
!byte $13 ;data8
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte ch5002148128004210
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte $50,chFFFFFFFFFFFF0000 ;fill
!byte $32 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte ch4002001000044100
!byte ch5002148128004210
!byte chF05A2CC52A554ABD
!byte chFCFCDCCCCCCCCCCC
!byte chCCCCCCCCCCCCCCCC
!byte chFCFCDCCCCCCCCCCC
!byte ch0000000000000000
!byte chFCFCDCCCCCCCCCCC
!byte chFCFCDCCCCCCCCCCC
!byte chFCFCDCCCCCCCCCCC
!byte chFEFEDED6D6D6D6D6
!byte chFCFC303030303030
!byte chFCFCE0C0C0C0C0C0
!byte chFCFCE0C0C0C0C0C0
!byte chF0F8CCCCCCCCCCCC
!byte ch0000000000000000
!byte chCCCCCCCCCCCCCCCC
!byte chFCFCDCCCCCCCCCCC
!byte chCCCCCCCCCCCCCCCC
!byte chFCFCE0C0C0C0C0C0
!byte chFCFCDCCCCCCCCCCC
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte chF05A2CC52A554ABD
!byte ch4002001000044100
!byte ch5002148128004210
!byte ch5002148128004210
!byte chCCCCCCCCCCECFCFC
!byte chCCCCCCCCCCECFCFC
!byte chF0F8CCCCCCCCCCCC
!byte ch0000000000000000
!byte chFCFCE0C0C0C0C0C0
!byte chF0F8CCCCCCCCCCCC
!byte chCCCCCCCCCCECFCFC
!byte chC6C6C6C6C6C6C6C6
!byte ch303030303030FCFC
!byte chFCFC1C0C0C1CFCFC
!byte chFCFCE0C0C0E0FCFC
!byte chCCCCCCCCCCECFCFC
!byte ch0000000000000000
!byte chFCFCDCCCCCCCCCCC
!byte chFCFCDCCCCCCCCCCC
!byte chCCCCCCCC78783030
!byte chFCFCE0C0C0E0FCFC
!byte chCCCCCCCCCCCCCCCC
!byte ch4002001000044100
!byte ch4002001000044100
!byte ch4002001000044100
!byte $96 ;skip
!byte $00 ;data8
!byte ch5555555555555555
!byte $e1,9
;,; *_001 .waits=30
;,; <- deps_itwilllead
;,; <- streamvars
!byte 0xD0,loopctr,0,10 ; set loopctr
.loop
; method 0 ( bytes ) -- 142 bytes (604 cumu)
; method 1 ( ibpc0 bytes ) -- 142 bytes (604 cumu)
; method 2 ( bytes ) -- 142 bytes (604 cumu)
; method 3 ( ibpc0 ibpcaa bytes ) -- 193 bytes (655 cumu)
; method 4 ( clrscr bytes ) -- 456 bytes (918 cumu)
; method 5 ( clrscr ibpc0 bytes ) -- 485 bytes (947 cumu)
; method 6 ( clrscr bytes ) -- 456 bytes (918 cumu)
; method 7 ( clrscr ibpc0 ibpcaa bytes ) -- 511 bytes (973 cumu)
; METHOD 0 CHOSEN
;,; <- chFFFFFFFFFFFFFFFF ; 88
;,; <- ch0000000000000000 ; 179
;,; <- chFCFC303030303030 ; 5
;,; <- chC6C6C6C6C6C6C6C6 ; 2
;,; <- chC0C0C0C0C0C0C0C0 ; 3
;,; <- chFCFCE0C0C0C0C0C0 ; 6
;,; <- chFCFCDCCCCCCCCCCC ; 12
;,; <- chF0F8CCCCCCCCCCCC ; 4
;,; <- chCCCCCCCCCCCCCCCC ; 5
;,; <- chFEFEFEFCFEFCFCF8 ; 2
;,; <- chFF7F7F3F7F3F3F1F ; 3
;,; <- ch303030303030FCFC ; 3
;,; <- ch3030303030303030 ; 2
;,; <- chD6D6D6D6D6F6FEFE ; 1
;,; <- chC0C0C0C0C0E0FCFC ; 3
;,; <- chFCFCE0C0C0E0FCFC ; 3
;,; <- chCCCCCCCCCCECFCFC ; 7
;,; <- chFCFC1C0C0C1CFCFC ; 2
;,; <- chFEFEFCFCF8F8F0E0 ; 6
;,; <- ch7F7F3F3F1F1F0F07 ; 7
;,; <- chF8F8F0F0E0E0C080 ; 7
;,; <- ch1F1F0F0F07070301 ; 5
;,; <- chC0F0FCFFFFFFFFFF ; 7
;,; <- ch00000000C0F0FCFF ; 7
;,; <- chF0E0C08000000000 ; 4
;,; <- ch7F3F1F0F07030100 ; 4
;,; <- chFFFFFFFFFEFEFEFE ; 5
;,; <- ch0008080800000000 ; 5
;,; <- ch000000000103070F ; 4
;,; <- chFEFEFEFEFFFFFFFF ; 6
;,; <- ch00000000C0E0F0F0 ; 5
;,; <- ch1F1F1F1F1F1F1F1F ; 5
;,; <- ch4002001000044100 ; 11
;,; <- ch5002148128004210 ; 9
;,; <- chC0C0C0E0E1E0E0E0 ; 6
;,; <- ch1F3F7FFFFFFF7F3F ; 5
;,; <- chF05A2CC52A554ABD ; 13
;,; <- chE0C0800000000000 ; 6
;,; <- ch3F3F3F3F3F3F3F3F ; 5
;,; <- ch80C0E0F0F8F8F8F8 ; 6
;,; <- ch3F3F3F1F1F0F0F07 ; 5
;,; <- chC0C0C0C0FFFFFFFF ; 6
;,; <- ch47436361C1C0C0C0 ; 5
;,; <- chFFFFFFFFFFFF0000 ; 18
;,; <- chFEFEDED6D6D6D6D6 ; 1
;,; <- chCCCCCCCC78783030 ; 1
; total unique chars in pic: 46 (worst case req 368 bytes)
!byte $DB,$F7 ;addr
!byte $e2,1;mode4
!byte $00 ;data4
!byte $05
!byte $CE,$F7 ;addr
!byte $e2,0;mode8
!byte $0D ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chC0F0FCFFFFFFFFFF
!byte ch0000000000000000
!byte $89 ;skip
!byte $0F ;data8
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch0000000000000000
!byte ch00000000C0F0FCFF
!byte $87 ;skip
!byte $10 ;data8
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch0000000000000000
!byte $86 ;skip
!byte $10 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte $86 ;skip
!byte $10 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte $86 ;skip
!byte $10 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F1F1F0F0F07
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F1F1F0F0F07
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F1F1F0F0F07
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F1F1F0F0F07
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F1F1F0F0F07
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte $86 ;skip
!byte $10 ;data8
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch47436361C1C0C0C0
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch47436361C1C0C0C0
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch47436361C1C0C0C0
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch47436361C1C0C0C0
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch47436361C1C0C0C0
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte $CF,$F7 ;addr
!byte $00 ;data8
!byte ch0000000000000000
!byte $e1,6
; method 0 ( bytes ) -- 128 bytes (732 cumu)
; method 1 ( ibpc0 bytes ) -- 128 bytes (732 cumu)
; method 2 ( bytes ) -- 128 bytes (732 cumu)
; method 3 ( ibpc0 ibpcaa bytes ) -- 182 bytes (786 cumu)
; method 4 ( clrscr bytes ) -- 456 bytes (1060 cumu)
; method 5 ( clrscr ibpc0 bytes ) -- 486 bytes (1090 cumu)
; method 6 ( clrscr bytes ) -- 456 bytes (1060 cumu)
; method 7 ( clrscr ibpc0 ibpcaa bytes ) -- 512 bytes (1116 cumu)
; METHOD 0 CHOSEN
;,; <- chFFFFFFFFFFFFFFFF ; 84
;,; <- ch0000000000000000 ; 180
;,; <- chFCFC303030303030 ; 5
;,; <- chC6C6C6C6C6C6C6C6 ; 2
;,; <- chC0C0C0C0C0C0C0C0 ; 3
;,; <- chFCFCE0C0C0C0C0C0 ; 6
;,; <- chFCFCDCCCCCCCCCCC ; 12
;,; <- chF0F8CCCCCCCCCCCC ; 4
;,; <- chCCCCCCCCCCCCCCCC ; 5
;,; <- chFEFEFEFCFEFCFCF8 ; 2
;,; <- chFF7F7F3F7F3F3F1F ; 3
;,; <- ch303030303030FCFC ; 3
;,; <- ch3030303030303030 ; 2
;,; <- chD6D6D6D6D6F6FEFE ; 1
;,; <- chC0C0C0C0C0E0FCFC ; 3
;,; <- chFCFCE0C0C0E0FCFC ; 3
;,; <- chCCCCCCCCCCECFCFC ; 7
;,; <- chFCFC1C0C0C1CFCFC ; 2
;,; <- chFEFEFCFCF8F8F0E0 ; 6
;,; <- ch7F7F3F3F1F1F0F07 ; 7
;,; <- chF8F8F0F0E0E0C080 ; 7
;,; <- ch1F1F0F0F07070301 ; 5
;,; <- chC0F0FCFFFFFFFFFF ; 7
;,; <- ch00000000C0F0FCFF ; 6
;,; <- chF0E0C08000000000 ; 4
;,; <- ch7F3F1F0F07030100 ; 4
;,; <- ch0008080800000000 ; 5
;,; <- ch000000000103070F ; 5
;,; <- chFFFFFFFFFEFEFEFE ; 4
;,; <- ch00000000C0E0F0F0 ; 6
;,; <- ch1F1F1F1F1F1F1F1F ; 5
;,; <- chFEFEFEFEFFFFFFFF ; 5
;,; <- ch4002001000044100 ; 11
;,; <- ch5002148128004210 ; 9
;,; <- chC0C0C0E0E1E0E0E0 ; 6
;,; <- ch1F3F7FFFFFFF7F3F ; 6
;,; <- chF05A2CC52A554ABD ; 13
;,; <- chE0C0800000000000 ; 6
;,; <- ch3F3F3F3F3F3F3F3F ; 6
;,; <- ch80C0E0F0F8F8F8F8 ; 6
;,; <- ch3F3F030303030323 ; 6
;,; <- chC0C0C0C0FFFFFFFF ; 6
;,; <- ch7F7F7F7FFFFFFFFF ; 6
;,; <- chFFFFFFFFFFFF0000 ; 18
;,; <- chFEFEDED6D6D6D6D6 ; 1
;,; <- chCCCCCCCC78783030 ; 1
; total unique chars in pic: 46 (worst case req 368 bytes)
!byte $CE,$F7 ;addr
!byte $0C ;data8
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte ch0000000000000000
!byte $8A ;skip
!byte $0F ;data8
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chC0F0FCFFFFFFFFFF
!byte ch0000000000000000
!byte $87 ;skip
!byte $0F ;data8
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte $87 ;skip
!byte $10 ;data8
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte $86 ;skip
!byte $10 ;data8
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte $86 ;skip
!byte $10 ;data8
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F030303030323
!byte $86 ;skip
!byte $10 ;data8
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0C0FFFFFFFF
!byte ch7F7F7F7FFFFFFFFF
!byte $e1,6
; method 0 ( bytes ) -- 133 bytes (865 cumu)
; method 1 ( ibpc0 bytes ) -- 133 bytes (865 cumu)
; method 2 ( bytes ) -- 133 bytes (865 cumu)
; method 3 ( ibpc0 ibpcaa bytes ) -- 186 bytes (918 cumu)
; method 4 ( clrscr bytes ) -- 462 bytes (1194 cumu)
; method 5 ( clrscr ibpc0 bytes ) -- 493 bytes (1225 cumu)
; method 6 ( clrscr bytes ) -- 462 bytes (1194 cumu)
; method 7 ( clrscr ibpc0 ibpcaa bytes ) -- 518 bytes (1250 cumu)
; METHOD 0 CHOSEN
;,; <- chFFFFFFFFFFFFFFFF ; 88
;,; <- ch0000000000000000 ; 179
;,; <- chFCFC303030303030 ; 5
;,; <- chC6C6C6C6C6C6C6C6 ; 2
;,; <- chC0C0C0C0C0C0C0C0 ; 3
;,; <- chFCFCE0C0C0C0C0C0 ; 6
;,; <- chFCFCDCCCCCCCCCCC ; 12
;,; <- chF0F8CCCCCCCCCCCC ; 4
;,; <- chCCCCCCCCCCCCCCCC ; 5
;,; <- chFEFEFEFCFEFCFCF8 ; 2
;,; <- chFF7F7F3F7F3F3F1F ; 3
;,; <- ch303030303030FCFC ; 3
;,; <- ch3030303030303030 ; 2
;,; <- chD6D6D6D6D6F6FEFE ; 1
;,; <- chC0C0C0C0C0E0FCFC ; 3
;,; <- chFCFCE0C0C0E0FCFC ; 3
;,; <- chCCCCCCCCCCECFCFC ; 7
;,; <- chFCFC1C0C0C1CFCFC ; 2
;,; <- chFEFEFCFCF8F8F0E0 ; 6
;,; <- ch7F7F3F3F1F1F0F07 ; 7
;,; <- chF8F8F0F0E0E0C080 ; 7
;,; <- ch1F1F0F0F07070301 ; 5
;,; <- chC0F0FCFFFFFFFFFF ; 7
;,; <- ch00000000C0F0FCFF ; 7
;,; <- ch7F3F1F0F07030100 ; 4
;,; <- chF0E0C08000000000 ; 4
;,; <- ch000000000103070F ; 5
;,; <- chFFFFFFFFFEFEFEFE ; 5
;,; <- ch0008080800000000 ; 4
;,; <- ch1F1F1F1F1F1F1F1F ; 6
;,; <- chFEFEFEFEFFFFFFFF ; 5
;,; <- ch00000000C0E0F0F0 ; 5
;,; <- ch4002001000044100 ; 11
;,; <- ch5002148128004210 ; 9
;,; <- ch1F3F7FFFFFFF7F3F ; 6
;,; <- chC0C0C0E0E1E0E0E0 ; 5
;,; <- chF05A2CC52A554ABD ; 13
;,; <- ch3F3F3F3F3F3F3F3F ; 12
;,; <- chE0C0800000000000 ; 5
;,; <- ch80C0E0F0F8F8F8F8 ; 5
;,; <- ch7F7F7F7F7F7F7F7F ; 6
;,; <- chF8F8F8F8C0C0C0C0 ; 5
;,; <- chFFFFFFFFFFFF0000 ; 18
;,; <- chFEFEDED6D6D6D6D6 ; 1
;,; <- chCCCCCCCC78783030 ; 1
; total unique chars in pic: 45 (worst case req 360 bytes)
!byte $DB,$E0 ;addr
!byte $56,$00 ;fill
!byte $CE,$F7 ;addr
!byte $0D ;data8
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch7F3F1F0F07030100
!byte chFFFFFFFFFFFFFFFF
!byte chF0E0C08000000000
!byte ch0000000000000000
!byte ch00000000C0F0FCFF
!byte $89 ;skip
!byte $0E ;data8
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0008080800000000
!byte ch000000000103070F
!byte chFFFFFFFFFEFEFEFE
!byte ch0000000000000000
!byte $88 ;skip
!byte $10 ;data8
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chFEFEFEFEFFFFFFFF
!byte ch00000000C0E0F0F0
!byte ch1F1F1F1F1F1F1F1F
!byte chC0F0FCFFFFFFFFFF
!byte $86 ;skip
!byte $10 ;data8
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte chC0C0C0E0E1E0E0E0
!byte ch1F3F7FFFFFFF7F3F
!byte chFFFFFFFFFFFFFFFF
!byte $86 ;skip
!byte $10 ;data8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte chE0C0800000000000
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte $86 ;skip
!byte $10 ;data8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte ch80C0E0F0F8F8F8F8
!byte ch3F3F3F3F3F3F3F3F
!byte chFFFFFFFFFFFFFFFF
!byte $86 ;skip
!byte $10 ;data8
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte chF8F8F8F8C0C0C0C0
!byte ch7F7F7F7F7F7F7F7F
!byte chFFFFFFFFFFFFFFFF
!byte $e1,6
; total compressed size 865 bytes
!byte $e0,<.loop,>.loop
",16379,True,4385.966576997919,median
"/** The MIT License (MIT)
Copyright (c) 2018 David Payne
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the ""Software""), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
/**********************************************
* Edit Settings.h for personalization
***********************************************/
#include ""Settings.h""
#define VERSION ""2.2""
#define HOSTNAME ""OctMon-""
#define CONFIG ""/conf.txt""
/* Useful Constants */
#define SECS_PER_MIN (60UL)
#define SECS_PER_HOUR (3600UL)
#define SECS_PER_DAY (SECS_PER_HOUR * 24L)
/* Useful Macros for getting elapsed time */
#define numberOfSeconds(_time_) (_time_ % SECS_PER_MIN)
#define numberOfMinutes(_time_) ((_time_ / SECS_PER_MIN) % SECS_PER_MIN)
#define numberOfHours(_time_) (( _time_% SECS_PER_DAY) / SECS_PER_HOUR)
#define elapsedDays(_time_) ( _time_ / SECS_PER_DAY)
// Initialize the oled display for I2C_DISPLAY_ADDRESS
// SDA_PIN and SCL_PIN
#if defined(DISPLAY_SH1106)
SH1106Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);
#else
SSD1306Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); // this is the default
#endif
OLEDDisplayUi ui( &display );
void drawProgress(OLEDDisplay *display, int percentage, String label);
void drawOtaProgress(unsigned int, unsigned int);
void drawScreen1(OLEDDisplay *display, OLEDDisplayUiState* state, int16_t x, int16_t y);
void drawScreen2(OLEDDisplay *display, OLEDDisplayUiState* state, int16_t x, int16_t y);
void drawScreen3(OLEDDisplay *display, OLEDDisplayUiState* state, int16_t x, int16_t y);
void drawHeaderOverlay(OLEDDisplay *display, OLEDDisplayUiState* state);
void drawClock(OLEDDisplay *display, OLEDDisplayUiState* state, int16_t x, int16_t y);
void drawWeather(OLEDDisplay *display, OLEDDisplayUiState* state, int16_t x, int16_t y);
void drawClockHeaderOverlay(OLEDDisplay *display, OLEDDisplayUiState* state);
// Set the number of Frames supported
const int numberOfFrames = 3;
FrameCallback frames[numberOfFrames];
FrameCallback clockFrame[2];
boolean isClockOn = false;
OverlayCallback overlays[] = { drawHeaderOverlay };
OverlayCallback clockOverlay[] = { drawClockHeaderOverlay };
int numberOfOverlays = 1;
// Time
TimeClient timeClient(UtcOffset);
long lastEpoch = 0;
long firstEpoch = 0;
long displayOffEpoch = 0;
String lastMinute = ""xx"";
String lastSecond = ""xx"";
String lastReportStatus = """";
boolean displayOn = true;
// OctoPrint Client
OctoPrintClient printerClient(OctoPrintApiKey, OctoPrintServer, OctoPrintPort, OctoAuthUser, OctoAuthPass);
int printerCount = 0;
// Weather Client
OpenWeatherMapClient weatherClient(WeatherApiKey, CityIDs, 1, IS_METRIC);
//declairing prototypes
void configModeCallback (WiFiManager *myWiFiManager);
int8_t getWifiQuality();
ESP8266WebServer server(WEBSERVER_PORT);
ESP8266HTTPUpdateServer serverUpdater;
String WEB_ACTIONS = "" Home""
"" Configure""
"" Weather""
"" Reset Settings""
"" Forget WiFi""
"" Firmware Update""
"" About"";
String CHANGE_FORM = """";
String WEATHER_FORM = """"
"""";
String COLOR_THEMES = """"
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
""""
"""";
// Change the externalLight to the pin you wish to use if other than the Built-in LED
int externalLight = LED_BUILTIN; // LED_BUILTIN is is the built in LED on the Wemos
void setup() {
Serial.begin(115200);
SPIFFS.begin();
delay(10);
//New Line to clear from start garbage
Serial.println();
// Initialize digital pin for LED (little blue light on the Wemos D1 Mini)
pinMode(externalLight, OUTPUT);
readSettings();
// initialize dispaly
display.init();
if (INVERT_DISPLAY) {
display.flipScreenVertically(); // connections at top of OLED display
}
display.clear();
display.display();
//display.flipScreenVertically();
display.setFont(ArialMT_Plain_16);
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.setContrast(255); // default is 255
display.drawString(64, 5, ""Printer Monitor\\nBy Qrome\\nV"" + String(VERSION));
display.display();
//WiFiManager
//Local intialization. Once its business is done, there is no need to keep it around
WiFiManager wifiManager;
// Uncomment for testing wifi manager
//wifiManager.resetSettings();
wifiManager.setAPCallback(configModeCallback);
String hostname(HOSTNAME);
hostname += String(ESP.getChipId(), HEX);
if (!wifiManager.autoConnect((const char *)hostname.c_str())) {// new addition
delay(3000);
WiFi.disconnect(true);
ESP.reset();
delay(5000);
}
// You can change the transition that is used
// SLIDE_LEFT, SLIDE_RIGHT, SLIDE_TOP, SLIDE_DOWN
ui.setFrameAnimation(SLIDE_LEFT);
ui.setTargetFPS(30);
ui.disableAllIndicators();
ui.setFrames(frames, (numberOfFrames));
frames[0] = drawScreen1;
frames[1] = drawScreen2;
frames[2] = drawScreen3;
clockFrame[0] = drawClock;
clockFrame[1] = drawWeather;
ui.setOverlays(overlays, numberOfOverlays);
// Inital UI takes care of initalising the display too.
ui.init();
if (INVERT_DISPLAY) {
display.flipScreenVertically(); //connections at top of OLED display
}
// print the received signal strength:
Serial.print(""Signal Strength (RSSI): "");
Serial.print(getWifiQuality());
Serial.println(""%"");
if (ENABLE_OTA) {
ArduinoOTA.onStart([]() {
Serial.println(""Start"");
});
ArduinoOTA.onEnd([]() {
Serial.println(""\\nEnd"");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf(""Progress: %u%%\\r"", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf(""Error[%u]: "", error);
if (error == OTA_AUTH_ERROR) Serial.println(""Auth Failed"");
else if (error == OTA_BEGIN_ERROR) Serial.println(""Begin Failed"");
else if (error == OTA_CONNECT_ERROR) Serial.println(""Connect Failed"");
else if (error == OTA_RECEIVE_ERROR) Serial.println(""Receive Failed"");
else if (error == OTA_END_ERROR) Serial.println(""End Failed"");
});
ArduinoOTA.setHostname((const char *)hostname.c_str());
if (OTA_Password != """") {
ArduinoOTA.setPassword(((const char *)OTA_Password.c_str()));
}
ArduinoOTA.begin();
}
if (WEBSERVER_ENABLED) {
server.on(""/"", displayPrinterStatus);
server.on(""/systemreset"", handleSystemReset);
server.on(""/forgetwifi"", handleWifiReset);
server.on(""/updateconfig"", handleUpdateConfig);
server.on(""/updateweatherconfig"", handleUpdateWeather);
server.on(""/configure"", handleConfigure);
server.on(""/configureweather"", handleWeatherConfigure);
server.onNotFound(redirectHome);
serverUpdater.setup(&server, ""/update"", www_username, www_password);
// Start the server
server.begin();
Serial.println(""Server started"");
// Print the IP address
String webAddress = ""http://"" + WiFi.localIP().toString() + "":"" + String(WEBSERVER_PORT) + ""/"";
Serial.println(""Use this URL : "" + webAddress);
display.clear();
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.setFont(ArialMT_Plain_10);
display.drawString(64, 10, ""Web Interface On"");
display.drawString(64, 20, ""You May Connect to IP"");
display.setFont(ArialMT_Plain_16);
display.drawString(64, 30, WiFi.localIP().toString());
display.drawString(64, 46, ""Port: "" + String(WEBSERVER_PORT));
display.display();
} else {
Serial.println(""Web Interface is Disabled"");
display.clear();
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.setFont(ArialMT_Plain_10);
display.drawString(64, 10, ""Web Interface is Off"");
display.drawString(64, 20, ""Enable in Settings.h"");
display.display();
}
flashLED(5, 500);
findMDNS(); //go find Octoprint Server by the hostname
Serial.println(""*** Leaving setup()"");
}
void findMDNS() {
if (OctoPrintHostName == """" || ENABLE_OTA == false) {
return; // nothing to do here
}
// We now query our network for 'web servers' service
// over tcp, and get the number of available devices
int n = MDNS.queryService(""http"", ""tcp"");
if (n == 0) {
Serial.println(""no services found - make sure OctoPrint server is turned on"");
return;
}
Serial.println(""*** Looking for "" + OctoPrintHostName + "" over mDNS"");
for (int i = 0; i < n; ++i) {
// Going through every available service,
// we're searching for the one whose hostname
// matches what we want, and then get its IP
Serial.println(""Found: "" + MDNS.hostname(i));
if (MDNS.hostname(i) == OctoPrintHostName) {
IPAddress serverIp = MDNS.IP(i);
OctoPrintServer = serverIp.toString();
OctoPrintPort = MDNS.port(i); // save the port
Serial.println(""*** Found OctoPrint Server "" + OctoPrintHostName + "" http://"" + OctoPrintServer + "":"" + OctoPrintPort);
writeSettings(); // update the settings
}
}
}
//************************************************************
// Main Looop
//************************************************************
void loop() {
//Get Time Update
if((getMinutesFromLastRefresh() >= minutesBetweenDataRefresh) || lastEpoch == 0) {
getUpdateTime();
}
if (lastMinute != timeClient.getMinutes() && !printerClient.isPrinting()) {
// Check status every 60 seconds
digitalWrite(externalLight, LOW);
lastMinute = timeClient.getMinutes(); // reset the check value
printerClient.getPrinterJobResults();
digitalWrite(externalLight, HIGH);
} else if (printerClient.isPrinting()) {
if (lastSecond != timeClient.getSeconds() && timeClient.getSeconds().endsWith(""0"")) {
lastSecond = timeClient.getSeconds();
// every 10 seconds while printing get an update
digitalWrite(externalLight, LOW);
printerClient.getPrinterJobResults();
digitalWrite(externalLight, HIGH);
}
}
checkDisplay(); // Check to see if the printer is on or offline and change display.
ui.update();
if (WEBSERVER_ENABLED) {
server.handleClient();
}
if (ENABLE_OTA) {
ArduinoOTA.handle();
}
}
void getUpdateTime() {
digitalWrite(externalLight, LOW); // turn on the LED
Serial.println();
if (displayOn && DISPLAYWEATHER) {
Serial.println(""Getting Weather Data..."");
weatherClient.updateWeather();
}
Serial.println(""Updating Time..."");
//Update the Time
timeClient.updateTime();
lastEpoch = timeClient.getCurrentEpoch();
Serial.println(""Local time: "" + timeClient.getAmPmFormattedTime());
digitalWrite(externalLight, HIGH); // turn off the LED
}
boolean authentication() {
if (IS_BASIC_AUTH && (strlen(www_username) >= 1 && strlen(www_password) >= 1)) {
return server.authenticate(www_username, www_password);
}
return true; // Authentication not required
}
void handleSystemReset() {
if (!authentication()) {
return server.requestAuthentication();
}
Serial.println(""Reset System Configuration"");
if (SPIFFS.remove(CONFIG)) {
redirectHome();
ESP.restart();
}
}
void handleUpdateWeather() {
if (!authentication()) {
return server.requestAuthentication();
}
DISPLAYWEATHER = server.hasArg(""isWeatherEnabled"");
WeatherApiKey = server.arg(""openWeatherMapApiKey"");
CityIDs[0] = server.arg(""city1"").toInt();
IS_METRIC = server.hasArg(""metric"");
writeSettings();
isClockOn = false; // this will force a check for the display
checkDisplay();
lastEpoch = 0;
redirectHome();
}
void handleUpdateConfig() {
boolean flipOld = INVERT_DISPLAY;
if (!authentication()) {
return server.requestAuthentication();
}
OctoPrintApiKey = server.arg(""octoPrintApiKey"");
OctoPrintHostName = server.arg(""octoPrintHostName"");
OctoPrintServer = server.arg(""octoPrintAddress"");
OctoPrintPort = server.arg(""octoPrintPort"").toInt();
OctoAuthUser = server.arg(""octoUser"");
OctoAuthPass = server.arg(""octoPass"");
DISPLAYCLOCK = server.hasArg(""isClockEnabled"");
IS_24HOUR = server.hasArg(""is24hour"");
INVERT_DISPLAY = server.hasArg(""invDisp"");
minutesBetweenDataRefresh = server.arg(""refresh"").toInt();
themeColor = server.arg(""theme"");
UtcOffset = server.arg(""utcoffset"").toFloat();
String temp = server.arg(""userid"");
temp.toCharArray(www_username, sizeof(temp));
temp = server.arg(""stationpassword"");
temp.toCharArray(www_password, sizeof(temp));
writeSettings();
findMDNS();
printerClient.getPrinterJobResults();
if (INVERT_DISPLAY != flipOld) {
ui.init();
if(INVERT_DISPLAY)
display.flipScreenVertically();
ui.update();
}
checkDisplay();
lastEpoch = 0;
redirectHome();
}
void handleWifiReset() {
if (!authentication()) {
return server.requestAuthentication();
}
//WiFiManager
//Local intialization. Once its business is done, there is no need to keep it around
redirectHome();
WiFiManager wifiManager;
wifiManager.resetSettings();
ESP.restart();
}
void handleWeatherConfigure() {
if (!authentication()) {
return server.requestAuthentication();
}
digitalWrite(externalLight, LOW);
String html = """";
server.sendHeader(""Cache-Control"", ""no-cache, no-store"");
server.sendHeader(""Pragma"", ""no-cache"");
server.sendHeader(""Expires"", ""-1"");
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, ""text/html"", """");
html = getHeader();
server.sendContent(html);
String form = WEATHER_FORM;
String isWeatherChecked = """";
if (DISPLAYWEATHER) {
isWeatherChecked = ""checked='checked'"";
}
form.replace(""%IS_WEATHER_CHECKED%"", isWeatherChecked);
form.replace(""%WEATHERKEY%"", WeatherApiKey);
form.replace(""%CITYNAME1%"", weatherClient.getCity(0));
form.replace(""%CITY1%"", String(CityIDs[0]));
String checked = """";
if (IS_METRIC) {
checked = ""checked='checked'"";
}
form.replace(""%METRIC%"", checked);
server.sendContent(form);
html = getFooter();
server.sendContent(html);
server.sendContent("""");
server.client().stop();
digitalWrite(externalLight, HIGH);
}
void handleConfigure() {
if (!authentication()) {
return server.requestAuthentication();
}
digitalWrite(externalLight, LOW);
String html = """";
server.sendHeader(""Cache-Control"", ""no-cache, no-store"");
server.sendHeader(""Pragma"", ""no-cache"");
server.sendHeader(""Expires"", ""-1"");
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, ""text/html"", """");
html = getHeader();
server.sendContent(html);
String form = CHANGE_FORM;
form.replace(""%OCTOKEY%"", OctoPrintApiKey);
form.replace(""%OCTOHOST%"", OctoPrintHostName);
form.replace(""%OCTOADDRESS%"", OctoPrintServer);
form.replace(""%OCTOPORT%"", String(OctoPrintPort));
form.replace(""%OCTOUSER%"", OctoAuthUser);
form.replace(""%OCTOPASS%"", OctoAuthPass);
String isClockChecked = """";
if (DISPLAYCLOCK) {
isClockChecked = ""checked='checked'"";
}
form.replace(""%IS_CLOCK_CHECKED%"", isClockChecked);
String is24hourChecked = """";
if (IS_24HOUR) {
is24hourChecked = ""checked='checked'"";
}
form.replace(""%IS_24HOUR_CHECKED%"", is24hourChecked);
String isInvDisp = """";
if (INVERT_DISPLAY) {
isInvDisp = ""checked='checked'"";
}
form.replace(""%IS_INVDISP_CHECKED%"", isInvDisp);
String options = """";
options.replace("">""+String(minutesBetweenDataRefresh)+""<"", "" selected>""+String(minutesBetweenDataRefresh)+""<"");
form.replace(""%OPTIONS%"", options);
String themeOptions = COLOR_THEMES;
themeOptions.replace("">""+String(themeColor)+""<"", "" selected>""+String(themeColor)+""<"");
form.replace(""%THEME_OPTIONS%"", themeOptions);
form.replace(""%UTCOFFSET%"", String(UtcOffset));
String isUseSecurityChecked = """";
if (IS_BASIC_AUTH) {
isUseSecurityChecked = ""checked='checked'"";
}
form.replace(""%IS_BASICAUTH_CHECKED%"", isUseSecurityChecked);
form.replace(""%USERID%"", String(www_username));
form.replace(""%STATIONPASSWORD%"", String(www_password));
server.sendContent(form);
html = getFooter();
server.sendContent(html);
server.sendContent("""");
server.client().stop();
digitalWrite(externalLight, HIGH);
}
void displayMessage(String message) {
digitalWrite(externalLight, LOW);
server.sendHeader(""Cache-Control"", ""no-cache, no-store"");
server.sendHeader(""Pragma"", ""no-cache"");
server.sendHeader(""Expires"", ""-1"");
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, ""text/html"", """");
String html = getHeader();
server.sendContent(String(html));
server.sendContent(String(message));
html = getFooter();
server.sendContent(String(html));
server.sendContent("""");
server.client().stop();
digitalWrite(externalLight, HIGH);
}
void redirectHome() {
// Send them back to the Root Directory
server.sendHeader(""Location"", String(""/""), true);
server.sendHeader(""Cache-Control"", ""no-cache, no-store"");
server.sendHeader(""Pragma"", ""no-cache"");
server.sendHeader(""Expires"", ""-1"");
server.send(302, ""text/plain"", """");
server.client().stop();
}
String getHeader() {
return getHeader(false);
}
String getHeader(boolean refresh) {
String menu = WEB_ACTIONS;
String html = """";
html += ""Printer Monitor"";
html += """";
if (refresh) {
html += """";
}
html += """";
html += """";
html += """";
html += """";
html += """";
html += """";
html += """";
html += ""
"";
return html;
}
String getFooter() {
int8_t rssi = getWifiQuality();
Serial.print(""Signal Strength (RSSI): "");
Serial.print(rssi);
Serial.println(""%"");
String html = ""
"";
html += ""
"";
html += """";
html += """";
return html;
}
void displayPrinterStatus() {
digitalWrite(externalLight, LOW);
String html = """";
server.sendHeader(""Cache-Control"", ""no-cache, no-store"");
server.sendHeader(""Pragma"", ""no-cache"");
server.sendHeader(""Expires"", ""-1"");
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, ""text/html"", """");
server.sendContent(String(getHeader(true)));
String displayTime = timeClient.getAmPmHours() + "":"" + timeClient.getMinutes() + "":"" + timeClient.getSeconds() + "" "" + timeClient.getAmPm();
if (IS_24HOUR) {
displayTime = timeClient.getHours() + "":"" + timeClient.getMinutes() + "":"" + timeClient.getSeconds();
}
html += ""Time: "" + displayTime + ""
"";
html += ""
"";
html += ""Host Name: "" + OctoPrintHostName + ""
"";
if (printerClient.getError() != """") {
html += ""Error: "" + printerClient.getError() + ""
"";
}
html += ""Status: "" + printerClient.getState() + ""
"";
if (printerClient.isPrinting()) {
html += ""File: "" + printerClient.getFileName() + ""
"";
float fileSize = printerClient.getFileSize().toFloat();
if (fileSize > 0) {
fileSize = fileSize / 1024;
html += ""File Size: "" + String(fileSize) + ""KB
"";
}
int filamentLength = printerClient.getFilamentLength().toInt();
if (filamentLength > 0) {
float fLength = float(filamentLength) / 1000;
html += ""Filament: "" + String(fLength) + ""m
"";
}
html += ""Tool Temperature: "" + printerClient.getTempToolActual() + ""° C
"";
html += ""Bed Temperature: "" + printerClient.getTempBedActual() + ""° C
"";
int val = printerClient.getProgressPrintTimeLeft().toInt();
int days = elapsedDays(val);
int hours = numberOfHours(val);
int minutes = numberOfMinutes(val);
int seconds = numberOfSeconds(val);
html += ""Est. Print Time Left: "" + zeroPad(hours) + "":"" + zeroPad(minutes) + "":"" + zeroPad(seconds) + ""
"";
val = printerClient.getProgressPrintTime().toInt();
days = elapsedDays(val);
hours = numberOfHours(val);
minutes = numberOfMinutes(val);
seconds = numberOfSeconds(val);
html += ""Printing Time: "" + zeroPad(hours) + "":"" + zeroPad(minutes) + "":"" + zeroPad(seconds) + ""
"";
html += """";
html += ""
"" + printerClient.getProgressCompletion() + ""%
"";
} else {
html += ""
"";
}
html += ""
Please Configure Weather API
"";
if (weatherClient.getError() != """") {
html += ""Weather Error: "" + weatherClient.getError() + ""
"";
}
} else {
html += """" + weatherClient.getCity(0) + "", "" + weatherClient.getCountry(0) + ""
"";
html += ""
"";
html += ""
!["" + weatherClient.getDescription(0) + ""](http://openweathermap.org/img/w/"" + weatherClient.getIcon(0) + "".png)
"";
html += weatherClient.getHumidity(0) + ""% Humidity
"";
html += weatherClient.getWind(0) + ""
"" + getSpeedSymbol() + "" Wind
"";
html += ""
"";
html += ""
"";
html += weatherClient.getCondition(0) + "" ("" + weatherClient.getDescription(0) + "")
"";
html += weatherClient.getTempRounded(0) + getTempSymbol(true) + ""
"";
html += "" Map It!
"";
html += ""
Door meeter
"";
message += ""Verze: "" + String(deviceSwVersion) + ""
"";
message += ""IP adresa: http://"" + WiFi.localIP().toString() + ""
"";
message += ""mDNS adresa: http://"" + String(deviceId) + "".local
"";
message += ""Popis REST API
"";
message += ""Zobrazeni vzdalenosti k predmetu,"";
message += ""http://"" + String(deviceId) + "".local/door
"";
message += ""PIN 5 = relé otevreni vrat
"";
server.send(200, ""text/html"", message);
}
void handleNotFound() { //pokud URL není nalezeno, používám pro laděni REST API
String message = """";
message = ""File Not Found\\n\\n"";
message += ""URI: "";
message += server.uri();
message += ""\\nMethod: "";
message += (server.method() == HTTP_GET) ? ""GET"" : ""POST"";
message += ""\\nArguments: "";
message += server.args();
message += ""\\n"";
for (uint8_t i = 0; i < server.args(); i++) {
message += "" "" + server.argName(i) + "": "" + server.arg(i) + ""\\n"";
}
server.send(404, ""text/plain"", message);
}
void resetPins() { //prvotní nastavení - nastav vystupni PIN na vypnuto
int pinCount = 0;
pinCount = sizeof(digitalPins) / sizeof(digitalPins[0]); //sizeof je mnozstvi bytu v digitalPins, ne pocet elementu. Proto se musi vydelit
for (int i = 0; i < pinCount ; i++) {
if (digitalWritePins[i]) { //nastaví pouze ty PINy, které jsou nasteveny jako výstupní
pinMode(digitalPins[i], OUTPUT);
if (relayOnHighPins[i]) { //pokud je vystupní rele spinano 1, tak nastaví 0, jinak obracene
digitalWrite(digitalPins[i], 0);
} else {
digitalWrite(digitalPins[i], 1);
}
}
}
}
void PressRelayButton(int pinNumber) { //PIN nastaví na zapnuto a na 1/2sekundu na vypnuto (zohlední i relayOnHighPins )
if (relayOnHighPins[pinNumber]) {
digitalWrite(digitalPins[pinNumber], 1);
delay (500);
digitalWrite(digitalPins[pinNumber], 0);
} else {
digitalWrite(digitalPins[pinNumber], 0);
delay (500);
digitalWrite(digitalPins[pinNumber], 1);
}
}
void setup() {
Serial.begin(9600); // Open serial monitor at 115200 baud to see ping results.
resetPins(); //nastaví digitální vystupní piny na vystupni a vypne je
//nezpůsobí to problém se Ultrazvukem ??
// ******* nastavení a připojení WIFI
//dns adresa
//WiFi.begin(ssid, password);
//Serial.println("""");
// ******* nastavení a připojení WIFI
//Unlike WiFi.begin() which automatically configures the WiFi shield to use DHCP, WiFi.config() allows you to manually set the network address of the shield.
//https://www.arduino.cc/en/Reference/WiFiConfig
WiFi.config(arduinoIP, gateway, subnet);
WiFi.mode(WIFI_STA); //není AP a nezobrazuje své SSID
WiFi.begin(ssid, password);
Serial.println("""");
// Wait for connection
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(""."");
}
Serial.println("""");
Serial.print(""Connected to "");
Serial.println(ssid);
Serial.print(""IP address: "");
Serial.println(WiFi.localIP());
if (MDNS.begin(deviceId)) { //mDNS je podporovano! Na deviceId.local je k nalezeni tento DEVICE
Serial.println(""MDNS responder started"");
}
// ******* nastavení poslouchání na GET/POST
// ******
//funkčnost pro DOOMastera
server.on(""/"", handleRoot); //zde je i zakladni help a popis
server.on(""/door/1"", handleClose); //testování s Omenem Doomaster - Vrata Close
server.on(""/door/0"", handleOpen); //testování s Omenem Doomaster - Vrata Open
//nastavení pomocí GET / POST
server.on(""/door"", HTTP_GET, handleGetDoor); //informace o dveřích
server.on(""/door"", HTTP_POST, handleSetDoor); //nastaví otvirani dveří
server.on(""/door"", HTTP_OPTIONS, handleOptionsDoor); //option pro dveře
server.on(""/door/config"", HTTP_GET, handleGetConfigDoor); //informace o dveřích
server.on(""/door/config"", HTTP_POST, handleConfigSetDoor); //nastaví otvirani dveří
server.on(""/door/config"", HTTP_OPTIONS, handleOptionsDoor); //option pro dveře
server.on(""/device"", HTTP_GET, handleGetDevice); //informace o zařízení
server.on(""/device"", HTTP_POST, handlePostDevice); //nastavi o zařízení
server.on(""/device"", HTTP_OPTIONS, handleOptionsDevice); //nastavi o zařízení
server.on(""/pins"", handleGetPinList); //vypise seznam pinů
//cteni PINu pomoci GET
server.on(""/pins/5"", HTTP_GET, handleGetDigiPin); //Garage Door Engine
//nastaveni PINu pomoci POST
server.on(""/pins/5"", HTTP_POST, handleSetDigiPin); //Garage Door Engine
//osetreni stavu CORS, pomoci OPTIONS
server.on(""/pins/5"", HTTP_OPTIONS, handleOptionsDigiPin); //Garage Door Engine
//cteni konfigurace jednotlivých PINu pomoci GET
server.on(""/pins/0/config"", HTTP_GET, handleGetConfigPin);
server.on(""/pins/1/config"", HTTP_GET, handleGetConfigPin);
server.on(""/pins/2/config"", HTTP_GET, handleGetConfigPin);
server.on(""/pins/3/config"", HTTP_GET, handleGetConfigPin);
server.on(""/pins/4/config"", HTTP_GET, handleGetConfigPin);
server.on(""/pins/5/config"", HTTP_GET, handleGetConfigPin); //Garage Door Engine
//server.on(""/pins/6/config"", HTTP_GET, handleGetConfigPin); //Garage Door
//server.on(""/pins/7/config"", HTTP_GET, handleGetConfigPin); //Garage Door
server.on(""/pins/8/config"", HTTP_GET, handleGetConfigPin);
//konfigurace jednotlivých PINu pomoci POST
server.on(""/pins/0/config"", HTTP_POST, handleConfigPin);
server.on(""/pins/1/config"", HTTP_POST, handleConfigPin);
server.on(""/pins/2/config"", HTTP_POST, handleConfigPin);
server.on(""/pins/3/config"", HTTP_POST, handleConfigPin);
server.on(""/pins/4/config"", HTTP_POST, handleConfigPin);
server.on(""/pins/5/config"", HTTP_POST, handleConfigPin); //Garage Door Engine
//server.on(""/pins/6/config"", HTTP_POST, handleConfigPin); //Garage Door
//server.on(""/pins/7/config"", HTTP_POST, handleConfigPin); //Garage Door
server.on(""/pins/8/config"", HTTP_POST, handleConfigPin);
//osetreni stavu CORS, pomoci OPTIONS
server.on(""/pins/0/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/1/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/2/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/3/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/4/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/5/config"", HTTP_OPTIONS, handleOptionsPin); //Garage Door Engine
//server.on(""/pins/6/config"", HTTP_OPTIONS, handleOptionsPin); //Garage Door
//server.on(""/pins/7/config"", HTTP_OPTIONS, handleOptionsPin);
server.on(""/pins/8/config"", HTTP_OPTIONS, handleOptionsPin);
server.onNotFound(handleNotFound);
server.begin();
Serial.println(""HTTP server started"");
}
void loop() {
// GARAGE Door Position
arduinoTime = millis(); // get Arduino real time
if (arduinoTime > doorMeasureTimeTemp + doorMeasureTimeDelay) { //read GarageDoorPosition every: doorMeasureTimeDelay
myGaradeDoor(); //run Garage Door Manager :-)
doorMeasureTimeTemp = arduinoTime;
}
//listening on HTTP for GET & POST
server.handleClient();
}
// ******
//funkčnost pro DOOMastera
//======= pro demo s Doomastera ==== 4.4.2018
void handleOpen() { //set OPEN door ... later on the Target Position like 40%
String message = """";
NewTargetDoorState = 0; //set 0 = open
NewTargetDoorOpen = 0; //set target postion like 40 % - not implemented yet
//==
changeDoorState = true; //New task: change the postion
server.send(200, ""text/plain"", ""Konfigurace nastavena"");
} //konec fce
void handleClose() { //set CLOSE door ... later on the Target Position like 40%
String message = """";
NewTargetDoorState = 1; //set 1=close
NewTargetDoorOpen = 0; //set target postion like 40 % - not implemented yet
//==
changeDoorState = true; //New task: change the postion
server.send(200, ""text/plain"", ""Konfigurace nastavena"");
} //konec fce
",12423,False,2435.402629420131,median
"###############################################################################
# Copyright 2019 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material (""Material"") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# ""License""), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 4, 0x90
CONST_TABLE:
_poly:
.quad 0x1, 0xC200000000000000
_twoone:
.quad 0x1, 0x100000000
_u128_str:
.byte 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
_mask1:
.quad 0xffffffffffffffff, 0x0
_mask2:
.quad 0x0, 0xffffffffffffffff
_inc1:
.quad 1,0
.p2align 4, 0x90
.globl _p8_AesGcmPrecompute_avx
_p8_AesGcmPrecompute_avx:
push %ebp
mov %esp, %ebp
push %esi
call .L__0000gas_1
.L__0000gas_1:
pop %esi
sub $(.L__0000gas_1-CONST_TABLE), %esi
movl (8)(%ebp), %eax
movdqu (%eax), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm0
psrlq $(63), %xmm4
movdqa %xmm4, %xmm3
pslldq $(8), %xmm4
psrldq $(8), %xmm3
por %xmm4, %xmm0
pshufd $(36), %xmm3, %xmm4
pcmpeqd ((_twoone-CONST_TABLE))(%esi), %xmm4
pand ((_poly-CONST_TABLE))(%esi), %xmm4
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm1
pshufd $(78), %xmm1, %xmm5
pshufd $(78), %xmm0, %xmm3
pxor %xmm1, %xmm5
pxor %xmm0, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm1, %xmm4
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm0, %xmm4
pxor %xmm1, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm3
psllq $(1), %xmm3
pxor %xmm1, %xmm3
psllq $(5), %xmm3
pxor %xmm1, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm1
pxor %xmm3, %xmm4
movdqa %xmm1, %xmm5
psrlq $(5), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm1
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm5
pshufd $(78), %xmm1, %xmm3
pxor %xmm2, %xmm5
pxor %xmm1, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm2, %xmm4
pclmulqdq $(0), %xmm1, %xmm2
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm1, %xmm4
pxor %xmm2, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm3
psllq $(1), %xmm3
pxor %xmm2, %xmm3
psllq $(5), %xmm3
pxor %xmm2, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm2, %xmm5
psrlq $(5), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm2
pxor %xmm4, %xmm2
movl (12)(%ebp), %eax
movdqu %xmm0, (%eax)
movdqu %xmm1, (16)(%eax)
movdqu %xmm2, (32)(%eax)
pop %esi
pop %ebp
ret
.p2align 4, 0x90
.globl _p8_AesGcmMulGcm_avx
_p8_AesGcmMulGcm_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
call .L__0001gas_2
.L__0001gas_2:
pop %esi
sub $(.L__0001gas_2-CONST_TABLE), %esi
movl (8)(%ebp), %edi
movl (12)(%ebp), %eax
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.p2align 4, 0x90
.globl _p8_AesGcmAuth_avx
_p8_AesGcmAuth_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
call .L__0002gas_3
.L__0002gas_3:
pop %esi
sub $(.L__0002gas_3-CONST_TABLE), %esi
movl (8)(%ebp), %edi
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movl (20)(%ebp), %eax
movdqa (%eax), %xmm1
movl (12)(%ebp), %ecx
movl (16)(%ebp), %edx
.p2align 4, 0x90
.Lauth_loopgas_3:
movdqu (%ecx), %xmm2
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm2
add $(16), %ecx
pxor %xmm2, %xmm0
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
sub $(16), %edx
jnz .Lauth_loopgas_3
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.p2align 4, 0x90
.globl _p8_AesGcmEnc_avx
_p8_AesGcmEnc_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
call .L__0003gas_4
.L__0003gas_4:
pop %esi
sub $(.L__0003gas_4-CONST_TABLE), %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_4
.p2align 4, 0x90
.Lblks4_loopgas_4:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 4, 0x90
.Lcipher4_loopgas_4:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_4
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm1
pxor (48)(%ebx), %xmm1
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm2
pxor (64)(%ebx), %xmm2
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm3
pxor (80)(%ebx), %xmm3
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm7
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_4
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
movdqa %xmm0, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm2, (64)(%ebx)
movdqa %xmm3, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_4
.Lcombine_hashgas_4:
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
movdqa (16)(%eax), %xmm7
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
movdqa (%eax), %xmm7
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pxor %xmm1, %xmm3
pxor %xmm2, %xmm3
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
pxor %xmm0, %xmm3
movdqa %xmm3, (32)(%ebx)
.Lsingle_block_procgas_4:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_4
.p2align 4, 0x90
.Lblk_loopgas_4:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 4, 0x90
.Lcipher_loopgas_4:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_4
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
movdqa %xmm0, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_4
.Lquitgas_4:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.p2align 4, 0x90
.globl _p8_AesGcmDec_avx
_p8_AesGcmDec_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
call .L__0004gas_5
.L__0004gas_5:
pop %esi
sub $(.L__0004gas_5-CONST_TABLE), %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_5
.p2align 4, 0x90
.Lblks4_loopgas_5:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 4, 0x90
.Lcipher4_loopgas_5:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_5
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm4
pxor (32)(%ebx), %xmm4
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm5
pxor (48)(%ebx), %xmm5
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm6
pxor (64)(%ebx), %xmm6
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm7
pxor (80)(%ebx), %xmm7
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm0
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_5
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
movdqa %xmm4, (32)(%ebx)
movdqa %xmm5, (48)(%ebx)
movdqa %xmm6, (64)(%ebx)
movdqa %xmm7, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_5
.Lcombine_hashgas_5:
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
movdqa (16)(%eax), %xmm0
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
movdqa (%eax), %xmm0
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pxor %xmm5, %xmm7
pxor %xmm6, %xmm7
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, (32)(%ebx)
.Lsingle_block_procgas_5:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_5
.p2align 4, 0x90
.Lblk_loopgas_5:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 4, 0x90
.Lcipher_loopgas_5:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_5
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm1
pxor (32)(%ebx), %xmm1
movdqa (%eax), %xmm0
pshufd $(78), %xmm1, %xmm4
pshufd $(78), %xmm0, %xmm2
pxor %xmm1, %xmm4
pxor %xmm0, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm1, %xmm3
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm0, %xmm3
pxor %xmm1, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
psllq $(1), %xmm2
pxor %xmm1, %xmm2
psllq $(5), %xmm2
pxor %xmm1, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm1
pxor %xmm2, %xmm3
movdqa %xmm1, %xmm4
psrlq $(5), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm1
pxor %xmm3, %xmm1
movdqa %xmm1, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_5
.Lquitgas_5:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
",16303,True,4905.035156987728,median
"; /* aes_asm.asm
; *
; * Copyright (C) 2006-2021 wolfSSL Inc.
; *
; * This file is part of wolfSSL.
; *
; * wolfSSL is free software; you can redistribute it and/or modify
; * it under the terms of the GNU General Public License as published by
; * the Free Software Foundation; either version 2 of the License, or
; * (at your option) any later version.
; *
; * wolfSSL is distributed in the hope that it will be useful,
; * but WITHOUT ANY WARRANTY; without even the implied warranty of
; * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; * GNU General Public License for more details.
; *
; * You should have received a copy of the GNU General Public License
; * along with this program; if not, write to the Free Software
; * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
; */
;
;
; /* See Intel Advanced Encryption Standard (AES) Instructions Set White Paper
; * by Israel, Intel Mobility Group Development Center, Israel Shay Gueron
; */
;
; /* This file is in intel asm syntax, see .s for at&t syntax */
;
fips_version = 0
IFDEF HAVE_FIPS
fips_version = 1
IFDEF HAVE_FIPS_VERSION
fips_version = HAVE_FIPS_VERSION
ENDIF
ENDIF
IF fips_version GE 2
fipsAh SEGMENT ALIAS("".fipsA$h"") 'CODE'
ELSE
_text SEGMENT
ENDIF
; /*
; AES_CBC_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,char ivec+16
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
AES_CBC_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8
;# parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8,[rsp+40]
mov r9d,[rsp+48]
mov r10,rcx
shr rcx,4
shl r10,60
je NO_PARTS
add rcx,1
NO_PARTS:
sub rsi,16
movdqa xmm1,[rdx]
LOOP_1:
pxor xmm1,[rdi]
pxor xmm1,[r8]
add rsi,16
add rdi,16
cmp r9d,12
aesenc xmm1,16[r8]
aesenc xmm1,32[r8]
aesenc xmm1,48[r8]
aesenc xmm1,64[r8]
aesenc xmm1,80[r8]
aesenc xmm1,96[r8]
aesenc xmm1,112[r8]
aesenc xmm1,128[r8]
aesenc xmm1,144[r8]
movdqa xmm2,160[r8]
jb LAST
cmp r9d,14
aesenc xmm1,160[r8]
aesenc xmm1,176[r8]
movdqa xmm2,192[r8]
jb LAST
aesenc xmm1,192[r8]
aesenc xmm1,208[r8]
movdqa xmm2,224[r8]
LAST:
dec rcx
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
jne LOOP_1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_CBC_encrypt ENDP
; void AES_CBC_decrypt_by4(const unsigned char* in,
; unsigned char* out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char* KS,
; int nr)
AES_CBC_decrypt_by4 PROC
; parameter 1: rdi
; parameter 2: rsi
; parameter 3: rdx
; parameter 4: rcx
; parameter 5: r8
; parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm15
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_4
add rcx, 1
DNO_PARTS_4:
mov r10, rcx
shl r10, 62
shr r10, 62
shr rcx, 2
movdqu xmm5, [rdx]
je DREMAINDER_4
sub rsi, 64
DLOOP_4:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqa xmm6, xmm1
movdqa xmm7, xmm2
movdqa xmm8, xmm3
movdqa xmm15, xmm4
movdqa xmm9, [r8]
movdqa xmm10, 16[r8]
movdqa xmm11, 32[r8]
movdqa xmm12, 48[r8]
pxor xmm1, xmm9
pxor xmm2, xmm9
pxor xmm3, xmm9
pxor xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 64[r8]
movdqa xmm10, 80[r8]
movdqa xmm11, 96[r8]
movdqa xmm12, 112[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 128[r8]
movdqa xmm10, 144[r8]
movdqa xmm11, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 160[r8]
movdqa xmm10, 176[r8]
movdqa xmm11, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 192[r8]
movdqa xmm10, 208[r8]
movdqa xmm11, 224[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
DLAST_4:
add rdi, 64
add rsi, 64
dec rcx
aesdeclast xmm1, xmm11
aesdeclast xmm2, xmm11
aesdeclast xmm3, xmm11
aesdeclast xmm4, xmm11
pxor xmm1, xmm5
pxor xmm2, xmm6
pxor xmm3, xmm7
pxor xmm4, xmm8
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqa xmm5, xmm15
jne DLOOP_4
add rsi, 64
DREMAINDER_4:
cmp r10, 0
je DEND_4
DLOOP_4_2:
movdqu xmm1, [rdi]
movdqa xmm15, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_4_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_4_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_4_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm5
movdqa xmm5, xmm15
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_4_2
DEND_4:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm15, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
ret
AES_CBC_decrypt_by4 ENDP
; void AES_CBC_decrypt_by6(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by6 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx, r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
movdqa [rsp+128], xmm14
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_6
add rcx, 1
DNO_PARTS_6:
mov r12, rax
mov r13, rdx
mov r14, rbx
mov rdx, 0
mov rax, rcx
mov rbx, 6
div rbx
mov rcx, rax
mov r10, rdx
mov rax, r12
mov rdx, r13
mov rbx, r14
cmp rcx, 0
movdqu xmm7, [rdx]
je DREMAINDER_6
sub rsi, 96
DLOOP_6:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqa xmm8, [r8]
movdqa xmm9, 16[r8]
movdqa xmm10, 32[r8]
movdqa xmm11, 48[r8]
pxor xmm1, xmm8
pxor xmm2, xmm8
pxor xmm3, xmm8
pxor xmm4, xmm8
pxor xmm5, xmm8
pxor xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 64[r8]
movdqa xmm9, 80[r8]
movdqa xmm10, 96[r8]
movdqa xmm11, 112[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 128[r8]
movdqa xmm9, 144[r8]
movdqa xmm10, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 160[r8]
movdqa xmm9, 176[r8]
movdqa xmm10, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 192[r8]
movdqa xmm9, 208[r8]
movdqa xmm10, 224[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
DLAST_6:
add rsi, 96
aesdeclast xmm1, xmm10
aesdeclast xmm2, xmm10
aesdeclast xmm3, xmm10
aesdeclast xmm4, xmm10
aesdeclast xmm5, xmm10
aesdeclast xmm6, xmm10
movdqu xmm8, [rdi]
movdqu xmm9, 16[rdi]
movdqu xmm10, 32[rdi]
movdqu xmm11, 48[rdi]
movdqu xmm12, 64[rdi]
movdqu xmm13, 80[rdi]
pxor xmm1, xmm7
pxor xmm2, xmm8
pxor xmm3, xmm9
pxor xmm4, xmm10
pxor xmm5, xmm11
pxor xmm6, xmm12
movdqu xmm7, xmm13
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
add rdi, 96
dec rcx
jne DLOOP_6
add rsi, 96
DREMAINDER_6:
cmp r10, 0
je DEND_6
DLOOP_6_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_6_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_6_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_6_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm7
movdqa xmm7, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_6_2
DEND_6:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
movdqa xmm14, [rsp+128]
add rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
ret
AES_CBC_decrypt_by6 ENDP
; void AES_CBC_decrypt_by8(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by8 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_8
add rcx, 1
DNO_PARTS_8:
mov r10, rcx
shl r10, 61
shr r10, 61
shr rcx, 3
movdqu xmm9, [rdx]
je DREMAINDER_8
sub rsi, 128
DLOOP_8:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqu xmm7, 96[rdi]
movdqu xmm8, 112[rdi]
movdqa xmm10, [r8]
movdqa xmm11, 16[r8]
movdqa xmm12, 32[r8]
movdqa xmm13, 48[r8]
pxor xmm1, xmm10
pxor xmm2, xmm10
pxor xmm3, xmm10
pxor xmm4, xmm10
pxor xmm5, xmm10
pxor xmm6, xmm10
pxor xmm7, xmm10
pxor xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 64[r8]
movdqa xmm11, 80[r8]
movdqa xmm12, 96[r8]
movdqa xmm13, 112[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 128[r8]
movdqa xmm11, 144[r8]
movdqa xmm12, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 160[r8]
movdqa xmm11, 176[r8]
movdqa xmm12, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 192[r8]
movdqa xmm11, 208[r8]
movdqa xmm12, 224[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
DLAST_8:
add rsi, 128
aesdeclast xmm1, xmm12
aesdeclast xmm2, xmm12
aesdeclast xmm3, xmm12
aesdeclast xmm4, xmm12
aesdeclast xmm5, xmm12
aesdeclast xmm6, xmm12
aesdeclast xmm7, xmm12
aesdeclast xmm8, xmm12
movdqu xmm10, [rdi]
movdqu xmm11, 16[rdi]
movdqu xmm12, 32[rdi]
movdqu xmm13, 48[rdi]
pxor xmm1, xmm9
pxor xmm2, xmm10
pxor xmm3, xmm11
pxor xmm4, xmm12
pxor xmm5, xmm13
movdqu xmm10, 64[rdi]
movdqu xmm11, 80[rdi]
movdqu xmm12, 96[rdi]
movdqu xmm9, 112[rdi]
pxor xmm6, xmm10
pxor xmm7, xmm11
pxor xmm8, xmm12
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
movdqu 96[rsi], xmm7
movdqu 112[rsi], xmm8
add rdi, 128
dec rcx
jne DLOOP_8
add rsi, 128
DREMAINDER_8:
cmp r10, 0
je DEND_8
DLOOP_8_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_8_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_8_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_8_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm9
movdqa xmm9, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_8_2
DEND_8:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
ret
AES_CBC_decrypt_by8 ENDP
; /*
; AES_ECB_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_encrypt
AES_ECB_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je EECB_NO_PARTS_4
add rdx,1
EECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je EECB_REMAINDER_4
sub rsi,64
EECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
EECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesenclast xmm1,xmm11
aesenclast xmm2,xmm11
aesenclast xmm3,xmm11
aesenclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne EECB_LOOP_4
add rsi,64
EECB_REMAINDER_4:
cmp r10,0
je EECB_END_4
EECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
aesenc xmm1,16[rcx]
aesenc xmm1,32[rcx]
aesenc xmm1,48[rcx]
aesenc xmm1,64[rcx]
aesenc xmm1,80[rcx]
aesenc xmm1,96[rcx]
aesenc xmm1,112[rcx]
aesenc xmm1,128[rcx]
aesenc xmm1,144[rcx]
cmp r8d,12
jb EECB_LAST_4_2
movdqu xmm2,192[rcx]
aesenc xmm1,160[rcx]
aesenc xmm1,176[rcx]
cmp r8d,14
jb EECB_LAST_4_2
movdqu xmm2,224[rcx]
aesenc xmm1,192[rcx]
aesenc xmm1,208[rcx]
EECB_LAST_4_2:
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne EECB_LOOP_4_2
EECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_encrypt ENDP
; /*
; AES_ECB_decrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_decrypt
AES_ECB_decrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je DECB_NO_PARTS_4
add rdx,1
DECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je DECB_REMAINDER_4
sub rsi,64
DECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
DECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesdeclast xmm1,xmm11
aesdeclast xmm2,xmm11
aesdeclast xmm3,xmm11
aesdeclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne DECB_LOOP_4
add rsi,64
DECB_REMAINDER_4:
cmp r10,0
je DECB_END_4
DECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
cmp r8d,12
aesdec xmm1,16[rcx]
aesdec xmm1,32[rcx]
aesdec xmm1,48[rcx]
aesdec xmm1,64[rcx]
aesdec xmm1,80[rcx]
aesdec xmm1,96[rcx]
aesdec xmm1,112[rcx]
aesdec xmm1,128[rcx]
aesdec xmm1,144[rcx]
jb DECB_LAST_4_2
cmp r8d,14
movdqu xmm2,192[rcx]
aesdec xmm1,160[rcx]
aesdec xmm1,176[rcx]
jb DECB_LAST_4_2
movdqu xmm2,224[rcx]
aesdec xmm1,192[rcx]
aesdec xmm1,208[rcx]
DECB_LAST_4_2:
aesdeclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne DECB_LOOP_4_2
DECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_decrypt ENDP
; /*
; void ,AES_128_Key_Expansion[const unsigned char*userkey
; unsigned char*key_schedule]/
; */
; . align 16,0x90
; . globl AES_128_Key_Expansion
AES_128_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov dword ptr 240[rsi],10
movdqu xmm1,[rdi]
movdqa [rsi],xmm1
ASSISTS:
aeskeygenassist xmm2,xmm1,1
call PREPARE_ROUNDKEY_128
movdqa 16[rsi],xmm1
aeskeygenassist xmm2,xmm1,2
call PREPARE_ROUNDKEY_128
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,4
call PREPARE_ROUNDKEY_128
movdqa 48[rsi],xmm1
aeskeygenassist xmm2,xmm1,8
call PREPARE_ROUNDKEY_128
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,16
call PREPARE_ROUNDKEY_128
movdqa 80[rsi],xmm1
aeskeygenassist xmm2,xmm1,32
call PREPARE_ROUNDKEY_128
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,64
call PREPARE_ROUNDKEY_128
movdqa 112[rsi],xmm1
aeskeygenassist xmm2,xmm1,80h
call PREPARE_ROUNDKEY_128
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,1bh
call PREPARE_ROUNDKEY_128
movdqa 144[rsi],xmm1
aeskeygenassist xmm2,xmm1,36h
call PREPARE_ROUNDKEY_128
movdqa 160[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
PREPARE_ROUNDKEY_128:
pshufd xmm2,xmm2,255
movdqa xmm3,xmm1
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pxor xmm1,xmm2
ret
AES_128_Key_Expansion ENDP
; /*
; void ,AES_192_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_192_Key_Expansion
AES_192_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+1*16 ; 8 = align stack , 1 xmm6, 16 bytes each
movdqa [rsp+0], xmm6
movdqu xmm1,[rdi]
movq xmm3,qword ptr 16[rdi]
movdqa [rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,1h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 16[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 32[rsi],xmm6
aeskeygenassist xmm2,xmm3,2h
call PREPARE_ROUNDKEY_192
movdqa 48[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,4h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 64[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 80[rsi],xmm6
aeskeygenassist xmm2,xmm3,8h
call PREPARE_ROUNDKEY_192
movdqa 96[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,10h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 112[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 128[rsi],xmm6
aeskeygenassist xmm2,xmm3,20h
call PREPARE_ROUNDKEY_192
movdqa 144[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,40h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 160[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 176[rsi],xmm6
aeskeygenassist xmm2,xmm3,80h
call PREPARE_ROUNDKEY_192
movdqa 192[rsi],xmm1
movdqa 208[rsi],xmm3
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
add rsp,8+1*16 ; 8 = align stack , 1 xmm6 16 bytes each
ret
PREPARE_ROUNDKEY_192:
pshufd xmm2,xmm2,55h
movdqu xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
pshufd xmm2,xmm1,0ffh
movdqu xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
AES_192_Key_Expansion ENDP
; /*
; void ,AES_256_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_256_Key_Expansion
AES_256_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
movdqu xmm1,[rdi]
movdqu xmm3,16[rdi]
movdqa [rsi],xmm1
movdqa 16[rsi],xmm3
aeskeygenassist xmm2,xmm3,1h
call MAKE_RK256_a
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 48[rsi],xmm3
aeskeygenassist xmm2,xmm3,2h
call MAKE_RK256_a
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 80[rsi],xmm3
aeskeygenassist xmm2,xmm3,4h
call MAKE_RK256_a
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 112[rsi],xmm3
aeskeygenassist xmm2,xmm3,8h
call MAKE_RK256_a
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 144[rsi],xmm3
aeskeygenassist xmm2,xmm3,10h
call MAKE_RK256_a
movdqa 160[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 176[rsi],xmm3
aeskeygenassist xmm2,xmm3,20h
call MAKE_RK256_a
movdqa 192[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 208[rsi],xmm3
aeskeygenassist xmm2,xmm3,40h
call MAKE_RK256_a
movdqa 224[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_256_Key_Expansion ENDP
MAKE_RK256_a:
pshufd xmm2,xmm2,0ffh
movdqa xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
ret
MAKE_RK256_b:
pshufd xmm2,xmm2,0aah
movdqa xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
IF fips_version GE 2
fipsAh ENDS
ELSE
_text ENDS
ENDIF
END
",16224,True,4068.1836386475247,median
"/*****************************************
* Code : ESPlorer I - Esp32 Car robot controlled by WiFi
* Programmer: Joao Lopes
* Comments : Using Web Socket Server instead Web Server to increase performance
* Not using JSON, do avoid extra overhead of this
* Camera software based on https://github.com/mudassar-tamboli/ESP32-OV7670-WebSocket-Camera
* Versions :
* ------ ---------- -------------------------
* 0.1.0 2018-10-30 First beta
* 0.2.0 2018-11-25 Using WebServer instead AsyncWebServer (not need this more)
* Using Web Socket Server to more performance
* 0.2.1 2018-12-14 Turbo mode
* 0.3.0 2018-12-25 Camera
* 0.3.1 2018-12-31 Slow speed mode
* 0.3.2 2018-01-08 Servo camera
* 0.3.3 2018-01-22 Few adjustments
* 0.3.4 2018-01-28 Few adjustments to avoid ESP32 crashes
* 0.3.5 2018-01-30 Camera optional
*****************************************/
/*
* Source for Esplorer I
*
* Copyright (C) 2018 Joao Lopes https://github.com/JoaoLopesF/ESPlorer_v1
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
*/
/*
* TODO known issues:
*/
////// Defines
#define VERSION ""0.3.4"" // Version
#define HOST_NAME ""esplorer"" // Host name
#define AP_SSID ""ESPlorer_AP"" // Soft AP
#define AP_PWD """"
#define HIGHER_PRIO_TASKS 7 // Higher priority for tasks
#define HIGH_PRIO_TASKS 5 // High priority for tasks
#define LOW_PRIO_TASKS 1 // Low priority for tasks (equal loop task)
//#define MAIN_TASK_DELAY 5 // Delay for main task
// Times
#define TIME_TO_INFO 3 // Time to process info (eg. camera fps, ...)
#define TIME_TO_RESTART_CAM 5 // Time to restart camera if not sendind data in this time
// Pinouts
#define PIN_LED_STATUS 5 // For led of status
// Motors
#define MOTOR_GPIO_IN1 18
#define MOTOR_GPIO_IN2 19
#define MOTOR_GPIO_IN3 25
#define MOTOR_GPIO_IN4 26
#define MOTOR_SPEED_MIN 25 // Minimum speed to move motor
#define DIF_SPEED_TURN 40 // Difference of speed to turn left/right
#define MOTOR_LEFT_MAX 80 // Maximum for left motor
#define MOTOR_RIGHT_MAX 80 // Maximum for right motor
#define MOTOR_LEFT_MAX_TURBO 100 // Maximum for left motor - turbo
#define MOTOR_RIGHT_MAX_TURBO 100 // Maximum for right motor - turbo
// Camera ?
#define CAMERA true
#ifdef CAMERA
// Servo for camera
#define PIN_SERVO_CAM 23 // Pin for camera servo
#define CH_SERVO_CAM 1 // Channel for camera servo
#define CAM_SERVO_MIN 15 // Minumum degrees for servo camera
#define CAM_SERVO_MAX 75 // Maximum degrees for servo camera
// Camera OV 7670
#define CAM_SIOD 21 // SDA
#define CAM_SIOC 22 // SCL
#define CAM_VSYNC 34
#define CAM_HREF 35
#define CAM_XCLK 32
#define CAM_PCLK 33
#define CAM_D0 27
#define CAM_D1 17
#define CAM_D2 16
#define CAM_D3 15
#define CAM_D4 14
#define CAM_D5 13
#define CAM_D6 12
#define CAM_D7 4
#endif // CAMERA
// Lights
#define PIN_LIGHTS 2 // Pin for car lights (leds)
// Debug
#define USE_REMOTEDEBUG true
#ifdef USE_REMOTEDEBUG
#define debugV(fmt, ...) rdebugVln(fmt, ##__VA_ARGS__)
#define debugD(fmt, ...) rdebugDln(fmt, ##__VA_ARGS__)
#define debugI(fmt, ...) rdebugIln(fmt, ##__VA_ARGS__)
#define debugE(fmt, ...) rdebugEln(fmt, ##__VA_ARGS__)
#define debugA(fmt, ...) rdebugVln(fmt, ##__VA_ARGS__)
#endif
// Maximum clients for socket server
//#define WEBSOCKETS_SERVER_CLIENT_MAX (1)
/////// Includes
#include
#include
#include
#include
#include ""esp_system.h""
#include ""esp_wifi.h""
//#include ""sdkconfig.h""
#include ""soc/soc.h""
#include ""soc/cpu.h""
#include ""soc/rtc_cntl_reg.h""
#include ""rom/ets_sys.h""
//#include ""esp_system_internal.h""
#include ""driver/rtc_cntl.h""
#include ""freertos/FreeRTOS.h""
#include ""freertos/task.h""
#include
#include
#include ""SPIFFS.h""
#include
#include // https://github.com/Links2004/arduinoWebSockets
#include
#include
#ifdef USE_REMOTEDEBUG
#include ""RemoteDebug.h"" // https://github.com/JoaoLopesF/RemoteDebug
#else
#include ""SerialDebug.h"" // https://github.com/JoaoLopesF/SerialDebug
#endif
#include ""ESP32MotorControl.h"" // https://github.com/JoaoLopesF/ESP32MotorControl
#include ""ESP32Servo.h"" // ESP32-Arduino-Servo library
// This project
#include ""Util.h"" // Utilities of this project
#include ""Fields.h""
#ifdef CAMERA
#include ""OV7670.h""
#endif
// C
extern ""C"" {
int rom_phy_get_vdd33();
}
/////// Variables
// Main task delay (can be changed by telnet - remote debug)
uint8_t mMainTaskDelay = 10; // Delay for main task
// Loop taksdelay (can be changed by telnet - remote debug)
uint8_t mLoopTaskDelay = 50; // Delay for loop task
// Socket server
WebSocketsServer mWebSocketServer(81); // Websocket server on port 81
boolean mConnected = false; // Connected ?
uint16_t mCountRecvWSData = 0; // Counter of receipt data
uint16_t mLastCountRecvWSData = 1; // Last ounter of receipt data
// Web Server
WebServer mWebServer(80);
#ifdef CAMERA
// Camera OV 7670
OV7670 *mCamera;
#endif
#ifdef USE_REMOTEDEBUG
// RemoteDebug
RemoteDebug Debug;
#endif
// MotorControl instance
ESP32MotorControl mMotorControl = ESP32MotorControl();
// Motors
uint8_t mMotorSpeed[2] = {0,0}; // Motors actual speed
boolean mMotorForward[2] = {true, true};// Motors forward ?
uint8_t mMotorSpeedMode = 1; // Speed mode: 1-1/1(normal) 2->1/2, 3->1/3, 4-1/4, ...
boolean mMotorResetSlowMode = false; // Reset slow mode ?
uint16_t mMotorTimeSlowMode = 10; // Time in millis for each step in slow mode
// Camera servo control
#ifdef CAMERA
ESP32Servo servo; // Servo for camera
uint8_t mCameraDegrees = 45; // Camera servo degreess - starts with medium position
// Camera
uint8_t mCameraFPS = 0; // Camera FPS
uint8_t mCountCameraFrames = 0; // Counter of camera frames
boolean mCameraDebug = false; // Camera debug ?
uint32_t mLastCameraSend = 0; // Last time of send data for camera
#endif
// Messages
boolean mSendInfo = false; // Send info ?
// Led of status
uint32_t mTimeLedStatus = 0; // Time to turn on/off the led of status
#ifdef PIN_LIGHTS
// Lights (leds)
boolean mLightsOn = false; // Lights of robot on ?
#endif
// Tasks
static TaskHandle_t xTaskMainHandler = NULL; // Main task
#ifdef CAMERA
static TaskHandle_t xTaskCameraHandler = NULL; // For Camera
#endif
// Mutex
#ifdef CAMERA
portMUX_TYPE mCamMutex = portMUX_INITIALIZER_UNLOCKED; // Mutex for camera task
#endif
//portMUX_TYPE mWSMutex = portMUX_INITIALIZER_UNLOCKED; // Mutex for callback of socketserver
/////// Routines
void setup() {
Serial.begin(230400);
delay(200);
Serial.println("""");
Serial.println(""Setup begin..."");
// Initialize motors
initializeMotors();
// GPIO - Input
// GPIO - Output
pinMode(PIN_LED_STATUS, OUTPUT);
digitalWrite(PIN_LED_STATUS, LOW);
#ifdef PIN_LIGHTS
pinMode(PIN_LIGHTS, OUTPUT);
digitalWrite(PIN_LIGHTS, LOW);
#endif
// Effect
for (uint8_t i=0; i<3; i++) {
delay(250);
digitalWrite(PIN_LED_STATUS, HIGH);
delay(250);
digitalWrite(PIN_LED_STATUS, LOW);
}
// SPIFFS
Serial.println(""Initializing SPIFFS..."");
SPIFFS.begin();
// WiFi
initializeWiFi();
// Initialize web socket server
initializeWebSocketServer();
// Initialize web server
initializeWebServer();
// Initialize OTA
initializeOTA();
#ifdef USE_REMOTEDEBUG
// Initialize RemoteDebug
initializeRemoteDebug();
#else
// SerialDebug
#ifndef DEBUG_DISABLE_DEBUGGER
// Add Functions and global variables to SerialDebug
// Add functions that can called from SerialDebug
//debugAddFunctionVoid(F(""function""), &function); // Example for function without args
//debugAddFunctionStr(F(""function""), &function); // Example for function with one String arg
//debugAddFunctionInt(F(""function""), &function); // Example for function with one int arg
// Add global variables that can showed/changed from SerialDebug
// Note: Only global, if pass local for SerialDebug, can be dangerous
debugAddGlobalUInt16_t(""motorSpeed[0]"", &mMotorControl.mMotorSpeed[0]);
debugAddGlobalBoolean(""motorForward[0]"", &mMotorControl.mMotorForward[0]);
debugAddGlobalUInt16_t(""motorSpeed[1]"", &mMotorControl.mMotorSpeed[1]);
debugAddGlobalBoolean(""motorForward[1]"", &mMotorControl.mMotorForward[1]);
#endif // DEBUG_DISABLE_DEBUGGER
#endif //USE_REMOTEDEBUG
// Create main task in CORE 1 - with higher priority
xTaskCreatePinnedToCore(&main_Task,
""main_Task"", 10240, NULL, HIGHER_PRIO_TASKS, &xTaskMainHandler, APP_CPU_NUM);
// Debug
Serial.println(""Setup end..."");
}
// Main task
static void main_Task(void *pvParameters) {
debugI(""Init main Task"");
// Variables
uint32_t curMillis = millis(); // Current millis time
uint32_t timeToSec = curMillis + 1000; // Time to one second
uint32_t timeToInfo = 0; // Time to info stuff
uint32_t timeToSlowMode = 0; // Time to slow mode
uint8_t motorSlowModeStep = 1; // Step of slow speed: only activate motor on 1
#ifdef CAMERA
uint8_t lastCamDegrees = 0; // Last camera degrees
uint32_t timeToMoveCamServo = 0; // Time to move servo
uint32_t timeToDettachCamServo = 0; // Time to detach servo
#endif
// Led of status
digitalWrite(PIN_LED_STATUS, HIGH);
mTimeLedStatus = curMillis + 1000;
////// Loop
for (;;) {
////// Time
// Give a time to ESP
delay(mMainTaskDelay);
// Current millis
curMillis = millis();
/////// Process in each loop
// Process requests
mWebSocketServer.loop();
#ifdef CAMERA
// Camera degrees changed ?
if (mCameraDegrees != lastCamDegrees) {
// Move servo
if (curMillis >= timeToMoveCamServo) { // Only if not moving now
if (timeToDettachCamServo == 0) { // Only if not attached
servo.attach(PIN_SERVO_CAM, CH_SERVO_CAM);
}
mCameraDegrees = constrain(mCameraDegrees, CAM_SERVO_MIN, CAM_SERVO_MAX);
debugI(""servo cam: %u"", mCameraDegrees);
servo.write(mCameraDegrees);
lastCamDegrees = mCameraDegrees; // Save it
timeToMoveCamServo = curMillis + 25;
timeToDettachCamServo = curMillis + 50;
}
}
// Camera servo dettach time ?
if (timeToDettachCamServo > 0 && curMillis >= timeToDettachCamServo) {
servo.detach();
timeToDettachCamServo = 0;
}
#endif // CAMERA
///// Process for n millis
// Motors
if (mMotorSpeed[0] > 0 || mMotorSpeed[1] > 0) { // Only if is moving ...
// Slow mode
if (mMotorSpeedMode > 1) { // Slow mode ?
// Reset it ?
if (mMotorResetSlowMode) {
if (mMotorTimeSlowMode < mMainTaskDelay) {
mMotorTimeSlowMode = mMainTaskDelay;
}
timeToSlowMode = curMillis + mMotorTimeSlowMode;
motorSlowModeStep = 1;
mMotorResetSlowMode = false;
}
// Time to slow mode
if (curMillis >= timeToSlowMode) { // Time to process it
timeToSlowMode = curMillis + mMotorTimeSlowMode; // Next time
uint8_t motorSpeedMode = mMotorSpeedMode;
// If is rotating, max speed mode = 2
if (mMotorForward[0] != mMotorForward[1] && motorSpeedMode > 2) {
motorSpeedMode = 2;
}
if (motorSlowModeStep == motorSpeedMode) {
motorSlowModeStep = 1;
} else {
motorSlowModeStep++;
}
if (motorSlowModeStep == 1) {
// Turn on it
if (mMotorForward[0]) {
mMotorControl.motorForward(0, mMotorSpeed[0]);
} else {
mMotorControl.motorReverse(0, mMotorSpeed[0]);
}
if (mMotorForward[1]) {
mMotorControl.motorForward(1, mMotorSpeed[1]);
} else {
mMotorControl.motorReverse(1, mMotorSpeed[1]);
}
} else {
// Turn off it
mMotorControl.motorsStop();
}
}
}
}
// Led of status
if (curMillis >= mTimeLedStatus) {
digitalWrite(PIN_LED_STATUS, !digitalRead(PIN_LED_STATUS));
mTimeLedStatus = curMillis + 1000;
}
///// Process for each second
// One second ?
if (curMillis >= timeToSec) {
timeToSec = curMillis + 1000; // Next time
// Connected ?
if (mConnected) {
// Task delete not working
//
// // Verify camera
//
// if (xTaskCameraHandler != NULL) {
//
// // Not sending data a time ...
//
// if ((curMillis - mLastCameraSend) >= (TIME_TO_RESTART_CAM * 1000)) {
//
// // Restart camera
//
// initializeCamera();
// }
// }
// Process info (for each n secs)
if (curMillis >= timeToInfo) {
timeToInfo = curMillis + (TIME_TO_INFO * 1000); // Next time
// Received data in this time ?
uint8_t recvDataPSec = 0;
if (mCountRecvWSData == 0 && mLastCountRecvWSData == 0) {
debugI(""not received data a time"");
// This is disabled now due crash wifi
// // Disconnection
//
// webSocketDisconnection(""mCountRecvWSData"");
// // Reset
//
// debugI(""resetting"");
//
// digitalWrite(PIN_LED_STATUS, HIGH);
//
// ESP.restart();
} else {
recvDataPSec = (uint8_t) roundf(mCountRecvWSData / (TIME_TO_INFO * 1.0f));
}
mLastCountRecvWSData = mCountRecvWSData; // Save it
mCountRecvWSData = 0; // Clear it
// ESP32 VDD
int readVDD = rom_phy_get_vdd33();
float voltageCaliber = 3.317f;
float readPhyCaliber = 6742.0f;
float factorCaliber = (voltageCaliber / readPhyCaliber);
// Voltage readed from ADC
float voltageEsp32 = (roundf((readVDD * factorCaliber) * 100.0f) / 100.0f);
#ifdef CAMERA
// Camera FPS
portENTER_CRITICAL(&mCamMutex);
mCameraFPS = (uint8_t) roundf(mCountCameraFrames / (TIME_TO_INFO * 1.0f));
mCountCameraFrames = 0;
portEXIT_CRITICAL(&mCamMutex);
mSendInfo = true;
debugI(""*** ESP32 VDD %f Camera fps (avg): %u data recv./s %u"", voltageEsp32, mCameraFPS, recvDataPSec);
#else
debugI(""*** ESP32 VDD data recv./s %u"", voltageEsp32, recvDataPSec);
#endif
}
}
}
}
////// End
// Delete task
vTaskDelete(NULL);
xTaskMainHandler = NULL;
}
// Task for camera
#ifdef CAMERA
static void camera_Task(void *pvParameters) {
debugI(""Init camera Task"");
////// Init camera
debugD(""camera init"");
mCamera = new OV7670(OV7670::Mode::QQVGA_RGB565, CAM_SIOD, CAM_SIOC, CAM_VSYNC,
CAM_HREF, CAM_XCLK, CAM_PCLK, CAM_D0, CAM_D1, CAM_D2, CAM_D3, CAM_D4,
CAM_D5, CAM_D6, CAM_D7);
// Send status
mWebSocketServer.sendTXT(0, ""caminit"");
mLastCameraSend = millis(); // To avoid disconnection, during camera initialization
////// Loop
uint32_t notific;
for (;;) {
// Wait fo notification
if (xTaskNotifyWait(0, 0xffffffff, ¬ific, portMAX_DELAY) == pdPASS) {
// Camera send next frame
if (mCameraDebug) debugV(""get camera frame data"");
if ((mCamera->yres / I2SCamera::blockSlice) > 1) { // 30, 60, 120
debugE(""camera block > 1"");
}
uint32_t timeCam = millis();
mCamera->startBlock = 1;
mCamera->endBlock = I2SCamera::blockSlice;
mCamera->oneFrame();
timeCam = (millis() - timeCam);
uint32_t timeSock = millis();
mLastCameraSend = timeSock;
mWebSocketServer.sendBIN(0, mCamera->frame, mCamera->xres * I2SCamera::blockSlice * 2);
timeSock = (millis() - timeSock);
if (mCameraDebug) debugV(""frame get in %lu ms and sended in %lu ms"", timeCam, timeSock);
// Count frames
portENTER_CRITICAL(&mCamMutex);
mCountCameraFrames++;
portEXIT_CRITICAL(&mCamMutex);
// Send motors info ? (neeeds be here to avoid errors on socket in browsers)
if (mSendInfo) {
String info = getInfo();
mWebSocketServer.sendTXT(0, info);
mSendInfo = false;
}
}
}
////// End
debugI(""camera task finish"");
// Delete task
vTaskDelete(NULL);
xTaskCameraHandler = NULL;
}
#endif // CAMERA
void loop() {
// // Not used - delay forever
//
// delay(portMAX_DELAY);
// Delay
delay(mLoopTaskDelay);
/////// Process with low priority
// Web Server // TODO: optimize this
mWebServer.handleClient();
#ifdef USE_REMOTEDEBUG
// Remote debug over telnet
Debug.handle();
#else
// SerialDebug handle
// NOTE: if in inactive mode (until receive anything from serial),
// it show only messages of always or errors level type
// And the overhead during inactive mode is very much low
debugHandle();
#endif
// ArduinoOTA handle
ArduinoOTA.handle();
}
///// Web socket server
void initializeWebSocketServer() { // Start a WebSocket server
// Initialize web socket server
mWebSocketServer.begin(); // start the websocket server
mWebSocketServer.onEvent(webSocketEvent); // if there's an incomming websocket message, go to function 'webSocketEvent'
Serial.println(""WebSocket server started."");
}
void finalizeWebSocketServer() { // Ends a WebSocket server
// Finalize web socket server
mWebSocketServer.close(); // stop the websocket server
mConnected = false;
mSendInfo = false;
mLastCountRecvWSData = 1;
debugI(""WebSocket server stopped."");
}
void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t payloadlength) { // When a WebSocket message is received
int blk_count = 0;
char ipaddr[26];
IPAddress localip;
switch (type) {
case WStype_DISCONNECTED: // if the websocket is disconnected
debugD(""[%u] Disconnected!\\n"", num);
// Disconnection
if (mConnected) {
webSocketDisconnection(""event"");
}
break;
case WStype_CONNECTED: { // if a new websocket connection is established
IPAddress ip = mWebSocketServer.remoteIP(num);
debugD(""[%u] Connected from %d.%d.%d.%d url: %s\\n"", num, ip[0], ip[1], ip[2], ip[3],
payload);
// Stop motors
carStop();
// Init variables
mConnected = true;
// Led de status
digitalWrite(PIN_LED_STATUS, HIGH);
mTimeLedStatus = millis() + 2000;
}
break;
case WStype_TEXT: // if new text data is received
{
if (payloadlength == 0) {
return;
}
//debugI(""[%u] get Text: %s"", num, payload);
// Count receipt data
mCountRecvWSData++;
// led of status (turn on in short time)
digitalWrite(PIN_LED_STATUS, HIGH);
mTimeLedStatus = millis() + 50;
// Process message
String ret = webSocketProcessMessage(payload, payloadlength);
// Send message to client
if (ret.length() > 0) {
mWebSocketServer.sendTXT(num, ret);
}
}
break;
case WStype_ERROR: // if new text data is received
debugE(""Error"");
break;
default:
debugE(""WStype %x not handled \\n"", type);
}
}
// Process message
String webSocketProcessMessage(uint8_t *payload, size_t length) {
//// Format of messages
//
// Code Format Description
// ---- --------------- -----------------------------------------
// init : init
// info :info ... informations
// feedback : feedback
// caminit : camera init
// camframe : camera request next frame
// cammmove :dir:dist camera move: direction and distance
// carstop : car stop
// carmove :dir:dist car move: direction and distance
// caropt :option car option
//
// Return message to client
String ret = """";
// Get a message
String message = (char*)payload;
// Debug
boolean showDebug = true;
#ifdef CAMERA
if (message.startsWith(""cam"") && !mCameraDebug) {
showDebug = false;
}
#endif
if (showDebug) debugV(""message: %s"", message.c_str());
// Get a fields
Fields fields(message, ':');
if (fields.size() == 0) {
return ret;
}
// Message type
String type = fields.getString(1);
if (showDebug) debugV(""type: %s"", type.c_str());
// Process types
if (type == ""init"") { // Init
// Stop motors
carStop();
} else if (type == ""reset"") { // Reset
// Stop motors
carStop();
// Reset
debugI(""resetting"");
digitalWrite(PIN_LED_STATUS, HIGH);
ESP.restart();
} else if (type == ""feedback"") { // Feedback
// Not need do anything - this is important only to mark time
} else if (type.startsWith(""cam"")) { // Camera
#ifdef CAMERA
boolean sendCameraData = false;
if (type == ""caminit"") {
// Camera init
initializeCamera();
sendCameraData = true;
} else if (type == ""camframe"") {
// Camera next frame
sendCameraData = true;
} else if (type == ""cammove"") {
// Camera servo move
if (fields.size() < 2) {
debugE(""invalid message"");
return ret;
}
String direction = fields.getString(2);
uint8_t distance = fields.getInt(3);
debugV(""dir: %s speed: %u"", direction.c_str(), distance);
// Camera servo move
camMove(direction, distance);
} else if (type == ""camend"") {
// Camera end moving
if (mMotorControl.mMotorSpeed[0] > 0 || mMotorControl.mMotorSpeed[1] > 0) {
// Car stop
carStop();
}
}
if (sendCameraData) {
// Send notification to it process in separate task
xTaskNotifyGive(xTaskCameraHandler);
}
#else
// Advice that no have camera
mWebSocketServer.sendTXT(0, ""camdis:"");
#endif
} else { // Car control
if (type == ""carstop"") {
debugV(""carstop"");
carStop();
} else if (type == ""carmove"") {
if (fields.size() < 3) {
debugE(""invalid message"");
return ret;
}
String direction = fields.getString(2);
uint8_t distance = fields.getInt(3);
boolean turbo = (fields.getChar(4) == 'y');
debugV(""dir: %s speed: %u turbo: %c"", direction.c_str(), distance, ((turbo)?'y':' '));
// Car move
carMove(direction, distance, turbo);
} else if (type == ""caropt"") {
// Car options
String option = fields.getString(2);
carOption (option);
#ifdef PIN_LIGHTS
} else if (type == ""carlights"") {
// Turn lights on/off
mLightsOn = !mLightsOn;
digitalWrite(PIN_LIGHTS, (mLightsOn)?HIGH:LOW);
// Request to send info
mSendInfo = true;
#endif
}
}
return ret;
}
// Return informations to send
String getInfo() {
// Motors
String leftStatus = """";
String rightStatus = """";
uint8_t leftSpeed = 0;
uint8_t rightSpeed = 0;
if (mMotorSpeed[0] == 0) {
leftStatus = ""Stop"";
} else if (mMotorForward[0]) {
leftStatus = ""Forward "";
leftSpeed = (uint8_t) roundf(mMotorSpeed[0] / mMotorSpeedMode);
leftStatus.concat(leftSpeed);
leftStatus.concat(""%"");
} else {
leftStatus = ""Reverse "";
leftSpeed = (uint8_t) roundf(mMotorSpeed[0] / mMotorSpeedMode);
leftStatus.concat(leftSpeed);
leftStatus.concat(""%"");
}
if (mMotorSpeed[1] == 0) {
rightStatus = ""Stop"";
} else if (mMotorForward[1]) {
rightStatus = ""Forward "";
rightSpeed = (uint8_t) roundf(mMotorSpeed[1] / mMotorSpeedMode);
rightStatus.concat(rightSpeed);
rightStatus.concat(""%"");
} else {
rightStatus = ""Reverse "";
rightSpeed = (uint8_t) roundf(mMotorSpeed[1] / mMotorSpeedMode);
rightStatus.concat(rightSpeed);
rightStatus.concat(""%"");
}
// Return informations to send
String ret = ""info:"";
ret.concat(mMotorSpeedMode);
ret.concat(':');
ret.concat(leftSpeed);
ret.concat(':');
ret.concat(leftStatus);
ret.concat(':');
ret.concat(rightSpeed);
ret.concat(':');
ret.concat(rightStatus);
ret.concat(':');
#ifdef CAMERA
ret.concat(mCameraFPS);
ret.concat(':');
ret.concat(mCameraDegrees);
ret.concat(':');
ret.concat((mLightsOn)?1:0);
#else
ret.concat(""0:0:0"");
#endif
return ret;
}
// Web socket disconnection
void webSocketDisconnection(const char* cause) {
debugI(""cause: %s"", cause);
// Stop motors
carStop();
// Init variables
mConnected = false;
mSendInfo = false;
mLastCountRecvWSData = 1;
// Task delete not working
// // Task of camera is running ?
//
// if (xTaskCameraHandler != NULL) {
// vTaskDelete(xTaskCameraHandler);
// delay(1);
// xTaskCameraHandler = NULL;
// }
// Disconnect socket clients
if (mWebSocketServer.connectedClients() > 0) {
debugI(""disconnect socket client"");
mWebSocketServer.disconnect();
}
// Led de status
digitalWrite(PIN_LED_STATUS, HIGH);
mTimeLedStatus = millis() + 5000;
}
////// WiFi
void initializeWiFi() {
////// Starts the WiFi
Serial.println(""Initializing WiFi ..."");
// Connect router (STA mode)
// TODO: necessary ?
WiFi.enableSTA(true);
delay(100);
// Connect (SSID e password stored)
WiFi.begin();
// WiFi.begin(""RSF-TEIA-T25"", ""nhandu15."");
// Wait connection
uint32_t timeout = millis() + 20000; // Time out
while (WiFi.status() != WL_CONNECTED && millis() < timeout) {
delay(250);
Serial.print(""."");
}
// Not connected yet ?
if (WiFi.status() != WL_CONNECTED) {
// SmartConfig
WiFi.beginSmartConfig();
// Wait for SmartConfig packet from mobile
Serial.println(""Waiting for SmartConfig."");
while (!WiFi.smartConfigDone()) {
delay(500);
Serial.print(""."");
}
Serial.println("""");
Serial.println(""SmartConfig received."");
//Wait for WiFi to connect to AP
Serial.println(""Waiting for WiFi"");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(""."");
}
}
Serial.println("""");
// Starts soft AP
// WiFi.mode (WIFI_MODE_AP);
//esp_wifi_set_ps (WIFI_PS_NONE);
WiFi.softAP(AP_SSID, AP_PWD);
// Set modem sleep to WiFi
// esp_wifi_set_ps(WIFI_PS_MIN_MODEM);
// End
Serial.printf(""WiFi started: STA IP: %s Soft AP IP: %s\\n"", WiFi.localIP().toString().c_str(), WiFi.softAPIP().toString().c_str());
}
////// Web server
// Initialize
void initializeWebServer() {
// Serve files on SPIFFS /www
mWebServer.onNotFound([]() {
if(!handleFileRead(mWebServer.uri()))
mWebServer.send(404, ""text/plain"", ""Not found"");
});
// Start
mWebServer.begin();
Serial.println(""Web server started"");
}
// Handle file read
boolean handleFileRead(String path) {
// Serve files on SPIFFS /www
path = ""/www"" + path;
if (path.endsWith(""/""))
path += ""index.htm"";
String contentType = getWebContentType(path);
debugV(""path: %s c.type: %s"", path.c_str(), contentType.c_str());
if (SPIFFS.exists(path)) {
File file = SPIFFS.open(path, ""r"");
size_t sent = mWebServer.streamFile(file, contentType);
file.close();
return true;
} else {
debugV(""File not exist"");
}
return false;
}
// Get Web Content type
String getWebContentType(String filename) {
if (filename.endsWith("".htm""))
return ""text/html"";
else if (filename.endsWith("".html""))
return ""text/html"";
else if (filename.endsWith("".css""))
return ""text/css"";
else if (filename.endsWith("".js""))
return ""application/javascript"";
else if (filename.endsWith("".png""))
return ""image/png"";
else if (filename.endsWith("".gif""))
return ""image/gif"";
else if (filename.endsWith("".jpg""))
return ""image/jpeg"";
else if (filename.endsWith("".ico""))
return ""image/x-icon"";
else if (filename.endsWith("".xml""))
return ""text/xml"";
else if (filename.endsWith("".pdf""))
return ""application/x-pdf"";
else if (filename.endsWith("".zip""))
return ""application/x-zip"";
else if (filename.endsWith("".gz""))
return ""application/x-gzip"";
return ""text/plain"";
}
#ifdef CAMERA
////// Camera
void initializeCamera() {
debugI("""");
// Task delete not working
// // Task is running ?
//
// if (xTaskCameraHandler != NULL) {
//
// debugI(""delete task"");
//
// vTaskDelete(xTaskCameraHandler);
// delay(1);
// xTaskCameraHandler = NULL;
// }
// Only if not running yet
if (xTaskCameraHandler == NULL) {
// Starts the task - higher priority
debugI(""create task"");
xTaskCreatePinnedToCore(&camera_Task,
""camera_Task"", 102400, NULL, HIGHER_PRIO_TASKS, &xTaskCameraHandler, APP_CPU_NUM);
}
}
#endif
////// Car robot control
// Move by direction and distance
void carMove(String& direction, uint8_t distance, boolean turbo) {
// // Variaveis
//
// int8_t motorSpeed[2] = {0, 0};
// boolean motorForward[2] = {true, true};
// // Turbo - only for forward
//
// if (!(direction == ""up"" || direction == ""left-up"" || direction == """")
// Debug
debugV(""dir. = %s dist = %u turbo=%c"", direction.c_str(), distance, ((turbo)?'y':' '));
// Calculate speed from distance
uint8_t speed[2];
if (distance < 20) {
speed[0] = 0;
speed[0] = 0;
} else {
speed[0] = map(distance, 20, 100, MOTOR_SPEED_MIN, ((turbo)?MOTOR_LEFT_MAX_TURBO:MOTOR_LEFT_MAX));
speed[1] = map(distance, 20, 100, MOTOR_SPEED_MIN, ((turbo)?MOTOR_RIGHT_MAX_TURBO:MOTOR_RIGHT_MAX));
}
// Speed in line (max)
uint16_t speedInLine = 0;
if (mMotorControl.mMotorForward[0] == mMotorControl.mMotorForward[1]) {
speedInLine = ((mMotorControl.mMotorSpeed[0] >= mMotorControl.mMotorSpeed[1]) ? mMotorControl.mMotorSpeed[0] : mMotorControl.mMotorSpeed[1]);
}
debugV(""speed: %u %u actual: %u"", speed[0], speed[1], speedInLine);
// Stopped ?
boolean stopped = (mMotorControl.mMotorSpeed[0] == 0 && mMotorControl.mMotorSpeed[1] == 0);
// Act in motors, depends on direction
if (direction == ""up"") {
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = true;
mMotorForward[1] = true;
} else if (direction == ""down"") {
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = false;
mMotorForward[1] = false;
} else if (direction == ""left"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = false;
mMotorForward[1] = true;
} else { // Turn left
mMotorSpeed[1] = speed[1];
// mMotorSpeed[0] = speed - DIF_SPEED2;
// if (mMotorSpeed[0] < 0) {
// mMotorSpeed[0] = 0;
// }
mMotorSpeed[0] = MOTOR_SPEED_MIN;
mMotorForward[0] = mMotorControl.mMotorForward[0];
mMotorForward[1] = mMotorControl.mMotorForward[1];
}
} else if (direction == ""right"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = true;
mMotorForward[1] = false;
} else { // Turn right
mMotorSpeed[0] = speed[0];
// mMotorSpeed[1] = speed - DIF_SPEED2;
// if (mMotorSpeed[1] < 0) {
// mMotorSpeed[1] = 0;
// }
mMotorSpeed[1] = MOTOR_SPEED_MIN;
mMotorForward[0] = mMotorControl.mMotorForward[0];
mMotorForward[1] = mMotorControl.mMotorForward[1];
}
} else if (direction == ""left-up"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = false;
mMotorForward[1] = true;
} else { // Turn left
mMotorSpeed[1] = speed[1];
mMotorSpeed[0] = (speed[0] > DIF_SPEED_TURN) ? (speed[0] - DIF_SPEED_TURN): (DIF_SPEED_TURN / 2);
if (mMotorSpeed[0] < 0) {
mMotorSpeed[0] = 0;
}
mMotorForward[0] = true;
mMotorForward[1] = true;
}
} else if (direction == ""left-down"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = false;
mMotorForward[1] = true;
} else { // Turn left
mMotorSpeed[1] = speed[1];
mMotorSpeed[0] = (speed[0] > DIF_SPEED_TURN) ? (speed[0] - DIF_SPEED_TURN): (DIF_SPEED_TURN / 2);
if (mMotorSpeed[0] < 0) {
mMotorSpeed[0] = 0;
}
mMotorForward[0] = false;
mMotorForward[1] = false;
}
} else if (direction == ""right-up"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = true;
mMotorForward[1] = false;
} else { // Turn right
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = (speed[1] > DIF_SPEED_TURN) ? (speed[1] - DIF_SPEED_TURN): (DIF_SPEED_TURN / 2);
if (mMotorSpeed[1] < 0) {
mMotorSpeed[1] = 0;
}
mMotorForward[0] = true;
mMotorForward[1] = true;
}
} else if (direction == ""right-down"") {
if (stopped || speedInLine == 0) { // Rotate
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = speed[1];
mMotorForward[0] = true;
mMotorForward[1] = false;
} else { // Turn right
mMotorSpeed[0] = speed[0];
mMotorSpeed[1] = (speed[1] > DIF_SPEED_TURN) ? (speed[1] - DIF_SPEED_TURN): (DIF_SPEED_TURN / 2);
if (mMotorSpeed[1] < 0) {
mMotorSpeed[1] = 0;
}
mMotorForward[0] = false;
mMotorForward[1] = false;
}
}
// Move the car
if (mMotorSpeed[0] > 0 || mMotorSpeed[1] > 0) {
debugV(""motorA: speed %u forward %d | motor B: speed %u forward %d"",
mMotorSpeed[0], mMotorForward[0], mMotorSpeed[1], mMotorForward[1]);
mMotorSpeed[0] = constrain(mMotorSpeed[0], 0, 100);
mMotorSpeed[1] = constrain(mMotorSpeed[1], 0, 100);
if (mMotorForward[0]) {
mMotorControl.motorForward(0, mMotorSpeed[0]);
} else {
mMotorControl.motorReverse(0, mMotorSpeed[0]);
}
if (mMotorForward[1]) {
mMotorControl.motorForward(1, mMotorSpeed[1]);
} else {
mMotorControl.motorReverse(1,mMotorSpeed[1]);
}
// Request to send info
mSendInfo = true;
} else {
// Stop car
carStop();
}
}
// Stop car
void carStop() {
// Stop motors
mMotorControl.motorsStop();
// Set variables
mMotorSpeed[0] = 0;
mMotorForward[0] = true;
mMotorSpeed[1] = 0;
mMotorForward[1] = true;
// Request to send info
mSendInfo = true;
}
// Car option
void carOption (String& option) {
debugD(""option = %s"", option.c_str());
if (option == ""slow"") {
// Slower speed mode
mMotorSpeedMode++;
mMotorResetSlowMode = true;
debugD(""slow -> mode=%u"", mMotorSpeedMode);
// Request to send info
mSendInfo = true;
} else if (option == ""fast"") {
// Faster speed mode
if (mMotorSpeedMode > 1) {
mMotorSpeedMode--;
mMotorResetSlowMode = true;
debugD(""faster -> mode=%u"", mMotorSpeedMode);
// Request to send info
mSendInfo = true;
}
}
}
////// Camera robot control
#ifdef CAMERA
// Move by direction and distance
void camMove(String& direction, uint8_t distance) {
debugV(""dir. = %s dist = %u"", direction.c_str(), distance);
// Act in motors, depends on direction
if (direction == ""up"") { // Camera up
mCameraDegrees = map(distance, 0, 100, 45, CAM_SERVO_MAX);
mSendInfo = true; // Request to send info
} else if (direction == ""down"") { // Camera down
mCameraDegrees = map((100 - distance), 0, 100, CAM_SERVO_MIN, 45);
mSendInfo = true; // Request to send info
} else { // Rotate car -> rotate camera
// Stop before
if (mMotorControl.mMotorSpeed[0] > 0 || mMotorControl.mMotorSpeed[1] > 0) {
carStop();
}
// Rotate
carMove(direction, distance, false);
}
}
#endif // CAMERA
////// OTA
void initializeOTA() {
// ArduinoOTA
ArduinoOTA.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = ""sketch"";
else // U_SPIFFS
type = ""filesystem"";
Serial.println(""Start updating "" + type);
}).onEnd([]() {
Serial.println(""\\nEnd"");
}).onProgress([](unsigned int progress, unsigned int total) {
Serial.printf(""Progress: %u%%\\r"", (progress / (total / 100)));
}).onError([](ota_error_t error) {
Serial.printf(""Error[%u]: "", error);
if (error == OTA_AUTH_ERROR) Serial.println(""Auth Failed"");
else if (error == OTA_BEGIN_ERROR) Serial.println(""Begin Failed"");
else if (error == OTA_CONNECT_ERROR) Serial.println(""Connect Failed"");
else if (error == OTA_RECEIVE_ERROR) Serial.println(""Receive Failed"");
else if (error == OTA_END_ERROR) Serial.println(""End Failed"");
});
ArduinoOTA.begin();
}
// Initialize Motors
void initializeMotors() {
// Attach motors of robot
Serial.println(""Initializing motors .."");
mMotorControl.attachMotors(MOTOR_GPIO_IN1, MOTOR_GPIO_IN2, MOTOR_GPIO_IN3, MOTOR_GPIO_IN4);
mMotorControl.motorsStop();
//mMotorControl.motorFullForward(0);
//mMotorControl.motorFullForward(1);
Serial.println(""Motors initialized"");
}
#ifdef USE_REMOTEDEBUG
/////// RemoteDebug
void initializeRemoteDebug() {
// RemoteDebug
Debug.begin(HOST_NAME);// Initiaze the telnet server
// Debug.setPassword(""r3m0t0.""); // Set password to connect on telnet
Debug.setResetCmdEnabled(true);// Enable the reset command
//Debug.showDebugLevel(false); // To not show debug levels
//Debug.showTime(true); // To show time
//Debug.showProfiler(true); // To show profiler - time between messages of Debug
// Good to ""begin ...."" and ""end ...."" messages
Debug.showProfiler(true);// Profiler
Debug.showColors(true);// Colors
Debug.setSerialEnabled(true); // if you wants serial echo - only recommended if ESP8266 is plugged in USB
String helpCmd = ""ota - wait upload via OTA\\n"";
helpCmd.concat(""mt [n] - main task delay to n\\n"");
helpCmd.concat(""lt [n] - loop task delay to n\\n"");
helpCmd.concat(""st [n] - motor slow time to n\\n"");
helpCmd.concat(""cd [on/off] - camera debug\\n"");
// helpCmd.concat(""mt stop - stop all motors"");
Debug.setHelpProjectsCmds(helpCmd);
Debug.setCallBackProjectCmds(&processCmdRemoteDebug);
}
// Process commands from RemoteDebug
void processCmdRemoteDebug() {
// mt speed [f/r] [a/b] - motor speed
// mt stop - stop all motors
String lastCmd = Debug.getLastCommand();
Fields fields(lastCmd, ' ');
if (fields.size() == 0) {
return;
}
String command = fields.getString(1);
rdebugVln(""lastCmd: %s cmd: %s"", lastCmd.c_str(), command.c_str());
if (command == ""mt"") { // Main task delay time
if (fields.size() >= 2) {
if (fields.isNum(2)) {
mMainTaskDelay = fields.getInt(2);
}
}
rdebugDln(""main task delay time -> %u"", mMainTaskDelay);
} else if (command == ""lt"") { // Loop task delay time
if (fields.size() >= 2) {
if (fields.isNum(2)) {
mLoopTaskDelay = fields.getInt(2);
}
}
rdebugDln(""loop task delay time -> %u"", mLoopTaskDelay);
} else if (command == ""st"") { // Motor slow time
if (fields.size() >= 2) {
if (fields.isNum(2)) {
mMotorTimeSlowMode = fields.getInt(2);
mMotorResetSlowMode = true;
}
}
rdebugDln(""motor slow time -> %u"",mMotorTimeSlowMode);
#ifdef CAMERA
} else if (command == ""cd"") { // Camera debug
if (fields.size() >= 2) {
mCameraDebug = (fields.getString(2) == ""on"");
}
rdebugDln(""camera debug %s"", ((mCameraDebug) ? ""on"" : ""off""));
#endif
} else if (command == ""ota"") {
// Wait upload via OTA
waitUploadOTA();
}
}
// Wait OTA upload (better performance on this)
void waitUploadOTA() {
debugA(""*** Waiting update via OTA ..."");
for(;;) {
// Update over air (OTA)
ArduinoOTA.handle();
// Give a time for o ESP
yield();
}
}
#endif
////////// Routines discontinued
// if (command == ""mt"") { // motor
//
// String firstOption = getFieldStr(lastCmd, 2, "" "");
//
// if (firstOption.length() == 0) {
//
//#ifdef MOTOR_ENCODERS
// rdebugD(""Motor A: speed: %u dir.: %c enc. %u | Motor B: speed: %u dir.: %c enc. %u\\n"",
// mMotorSpeed[0], mMotorDirection[0], mMotorEncoderSec[0],
// mMotorSpeed[1], mMotorDirection[1], mMotorEncoderSec[1]);
//#else
// rdebugD(""Motor A: speed: %u dir.: %c | Motor B: speed: %u dir.: %c \\n"",
// mMotorSpeed[0], mMotorDirection[0],
// mMotorSpeed[1], mMotorDirection[1]);
//#endif
// return;
//
// } else if (firstOption == ""stop"") {
//
// rdebugD(""Stopping motors\\n"");
//
// motorStop();
//
// } else {
//
// if (isNumeric(firstOption)) {
//
// int16_t speed = firstOption.toInt();
//
// if (speed == -1) {
// rdebugEln(""motor speed invalid"");
// return;
// }
//
// String direction = getFieldStr(lastCmd, 3, "" "");
//
// if (direction != """" && direction != ""f"" && direction != ""r"") {
// rdebugEln(""direction must be f or r"");
// return;
// }
//
// String motor = """";
// uint8_t motorNumber = 2; // 2-> all
//
// if (direction.length() > 0) {
//
// motor = getFieldStr(lastCmd, 4, "" "");
//
// if (motor.length() > 0) {
//
// if (motor != ""a"" && motor != ""b"") {
// rdebugEln(""motor must be a or b"");
// return;
// }
//
// switch (motor.charAt(0)) {
//
// case 'a': // Motor A
//
// motorNumber = 0;
// mMotorDirection[0] = direction.charAt(0);
// break;
//
// case 'b': // Motor B
//
// motorNumber = 1;
// mMotorDirection[1] = direction.charAt(0);
// break;
// }
// }
// }
//
// // Set speed
//
// switch (motorNumber) {
//
// case 0: // Motor A
// case 1: // Motor B
//
// rdebugDln(""motor speed mt: %u dir: %c spd: %u"", motorNumber, mMotorDirection[motorNumber], speed);
//
// motorSpeed(motorNumber, mMotorDirection[motorNumber], speed);
// break;
//
// case 2: // Motor A+B
//
// if (direction.length() == 0) {
// direction = ""f"";
// }
//
// rdebugDln(""motor speed dir: %c spd: %u"", direction.charAt(0), speed);
//
// motorSpeed(direction.charAt(0), speed);
// break;
// }
//
// } else {
//
// rdebugEln(""option invalid"");
// }
//
// }
//
// } else if (command == ""ota"") {
////// End
",12487,False,2034.9263624991831,median
"/*
KISS OSD CONFIG TOOL
by Alexander Wolf (awolf78@gmx.de)
for everyone who loves KISS
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
For more information, please refer to
*/
// CONFIGURATION
// motors magnepole count (to display the right RPMs)
//=============================
#define MAGNETPOLECOUNT 14 // 2 for ERPMs
// Filter for ESC datas (higher value makes them less erratic) 0 = no filter, 20 = very strong filter
//=============================
#define ESC_FILTER 10
/* Low battery warning config
-----------------------------
This feature will show a flashing ""BATTERY LOW"" warning just below the center of your
display when bat_mAh_warning is exceeded - letting you know when it is time to land.
I have found the mAh calculation of my KISS setup (KISS FC with 24RE ESCs using ESC telemetry) to
be very accurate, so be careful when using other ESCs - mAh calculation might not be as accurate.
While disarmed, yaw to the right. This will display the selected battery. Roll left or right to
select a different battery. Pitch up or down to change the battery capacity. The warning will be
displayed according to the percentage configured in the menu. Enter the menu with a yaw to the left
for more than 3 seconds. Default is 23%, so if you have a 1300 mAh battery, it would start warning
you at 1001 mAh used capacity.
=============================*/
static const int16_t BAT_MAH_INCREMENT = 50;
// END OF CONFIGURATION
//=========================================================================================================================
// internals
//=============================
//#define DEBUG
//#define PROTODEBUG
#define KISS_OSD_CONFIG
#include
#include ""MAX7456.h""
#include ""Max7456Config.h""
#include
#include ""SerialPort.h""
#include ""CSettings.h""
#include ""CStickInput.h""
#include ""fixFont.h""
#include ""CMeanFilter.h""
#include ""Config.h""
#ifdef STEELE_PDB
static const char KISS_OSD_VER[] PROGMEM = ""steele pdb config v2.5.1"";
#elif defined(BF32_MODE)
static const char KISS_OSD_VER[] PROGMEM = ""bf32 osd config v2.5"";
#else
static const char KISS_OSD_VER[] PROGMEM = ""kiss osd config v2.5.1"";
#endif
#if (defined(IMPULSERC_VTX) || defined(STEELE_PDB)) && !defined(STEELE_PDB_OVERRIDE)
const uint8_t osdChipSelect = 10;
#else
const uint8_t osdChipSelect = 6;
#endif
const byte masterOutSlaveIn = MOSI;
const byte masterInSlaveOut = MISO;
const byte slaveClock = SCK;
const byte osdReset = 2;
static uint8_t serialBuf[512];
CMax7456Config OSD( osdChipSelect );
SerialPort<0, 64, 0> NewSerial;
CStickInput inputChecker;
CSettings settings(serialBuf);
static int16_t DV_PPMs[CSettings::DISPLAY_DV_SIZE];
static bool OSD_ITEM_BLINK[CSettings::OSD_ITEMS_SIZE];
static uint8_t itemLengthOK[CSettings::OSD_ITEMS_POS_SIZE];
static bool correctItemsOnce = false;
#ifdef IMPULSERC_VTX
static volatile uint8_t vTxChannel, vTxBand, vTxPower, oldvTxChannel, oldvTxBand;
const uint8_t VTX_BAND_COUNT = 5;
const uint8_t VTX_CHANNEL_COUNT = 8;
//static unsigned long changevTxTime = 0;
static const char bandSymbols[][2] PROGMEM = { {'a', 0x00} , {'b', 0x00}, {'e', 0x00}, {'f', 0x00}, {'r', 0x00}};
const uint16_t vtx_frequencies[VTX_BAND_COUNT][VTX_CHANNEL_COUNT] PROGMEM = {
{ 5865, 5845, 5825, 5805, 5785, 5765, 5745, 5725 }, //A
{ 5733, 5752, 5771, 5790, 5809, 5828, 5847, 5866 }, //B
{ 5705, 5685, 5665, 5645, 5885, 5905, 5925, 5945 }, //E
{ 5740, 5760, 5780, 5800, 5820, 5840, 5860, 5880 }, //F
{ 5658, 5695, 5732, 5769, 5806, 5843, 5880, 5917 } //R
};
void setvTxSettings()
{
oldvTxChannel = vTxChannel = settings.s.m_vTxChannel;
oldvTxBand = vTxBand = settings.s.m_vTxBand;
vTxPower = settings.s.m_vTxPower;
}
#endif
void cleanScreen()
{
OSD.clear();
while (!OSD.clearIsBusy());
}
static uint8_t lastTempUnit;
static boolean triggerCleanScreen = true;
void checkVideoMode()
{
uint8_t videoSys = OSD.videoSystem();
if(videoSys != settings.m_videoMode)
{
settings.m_videoMode = videoSys;
if(settings.m_videoMode == MAX7456_PAL) settings.ROWS = 15;
else settings.ROWS = 13;
OSD.setDefaultSystem(videoSys);
OSD.setTextArea(settings.COLS, settings.ROWS);
triggerCleanScreen = true;
}
}
void setupMAX7456()
{
#if (defined(IMPULSERC_VTX) || defined(STEELE_PDB)) && !defined(STEELE_PDB_OVERRIDE)
MAX7456Setup();
delay(100);
#endif
OSD.begin(settings.COLS,13);
#ifdef FORCE_NTSC
OSD.setDefaultSystem(MAX7456_NTSC);
settings.ROWS = 13;
#elif defined(FORCE_PAL)
OSD.setDefaultSystem(MAX7456_PAL);
settings.ROWS = 15;
#else
delay(1000);
checkVideoMode();
#endif
OSD.setTextArea(settings.COLS, settings.ROWS);
OSD.setSwitchingTime( 5 );
OSD.setCharEncoding( MAX7456_ASCII );
OSD.display();
delay(100);
OSD.setTextOffset(settings.s.m_xOffset, settings.s.m_yOffset);
}
void resetBlinking()
{
uint8_t i = 0;
for (i = 0; i < CSettings::OSD_ITEMS_SIZE; i++)
{
OSD_ITEM_BLINK[i] = false;
}
}
void setup()
{
SPI.begin();
SPI.setClockDivider( SPI_CLOCK_DIV2 );
setupMAX7456();
settings.cleanEEPROM();
settings.ReadSettings();
OSD.setTextOffset(settings.s.m_xOffset, settings.s.m_yOffset);
//clean used area
while (!OSD.notInVSync());
cleanScreen();
#ifdef IMPULSERC_VTX
//Ignore setting because this is critical to making sure we can detect the
//VTX power jumper being installed. If we aren't using 5V ref there is
//the chance we will power up on wrong frequency.
analogReference(DEFAULT);
setvTxSettings();
vtx_init();
vtx_set_frequency(vTxBand, vTxChannel);
vtx_flash_led(5);
#endif
lastTempUnit = settings.s.m_tempUnit;
settings.SetupPPMs(DV_PPMs);
resetBlinking();
uint8_t i;
for (i = 0; i < CSettings::OSD_ITEMS_POS_SIZE; i++) itemLengthOK[i] = 0;
NewSerial.begin(115200);
}
static int16_t throttle = 0;
static int16_t roll = 0;
static int16_t pitch = 0;
static int16_t yaw = 0;
static uint16_t current = 0;
static int8_t armed = 0;
static int8_t idleTime = 0;
static int16_t LipoVoltage = 0;
static int16_t LipoMAH = 0;
static int16_t previousMAH = 0;
static int16_t totalMAH = 0;
static int16_t MaxAmps = 0;
static int16_t MaxC = 0;
static int16_t MaxRPMs = 0;
static int16_t MaxWatt = 0;
static int16_t MaxTemp = 0;
static int16_t MinBat = 0;
static int16_t motorKERPM[4] = {0, 0, 0, 0};
static int16_t maxKERPM[4] = {0, 0, 0, 0};
static int16_t motorCurrent[4] = {0, 0, 0, 0};
static int16_t maxCurrent[4] = {0, 0, 0, 0};
static int16_t ESCTemps[4] = {0, 0, 0, 0};
static int16_t maxTemps[4] = {0, 0, 0, 0};
static int16_t ESCVoltage[4] = {0, 0, 0, 0};
static int16_t minVoltage[4] = {10000, 10000, 10000, 10000};
static int16_t ESCmAh[4] = {0, 0, 0, 0};
static int16_t AuxChanVals[5] = {0, 0, 0, 0, 0};
static unsigned long start_time = 0;
static unsigned long time = 0;
static unsigned long old_time = 0;
static unsigned long total_time = 0;
static unsigned long DV_change_time = 0;
static int16_t last_Aux_Val = -10000;
static boolean armedOnce = false;
static boolean showBat = false;
static boolean settingChanged = false;
static uint8_t statPage = 0;
uint32_t ESC_filter(uint32_t oldVal, uint32_t newVal) {
return (uint32_t)((uint32_t)((uint32_t)((uint32_t)oldVal * ESC_FILTER) + (uint32_t)newVal)) / (ESC_FILTER + 1);
}
int16_t findMax4(int16_t maxV, int16_t *values, int16_t length)
{
for (uint8_t i = 0; i < length; i++)
{
if (values[i] > maxV)
{
maxV = values[i];
}
}
return maxV;
}
int16_t findMax(int16_t maxV, int16_t newVal)
{
if (newVal > maxV) {
return newVal;
}
return maxV;
}
int16_t findMin(int16_t minV, int16_t newVal)
{
if (newVal < minV) {
return newVal;
}
return minV;
}
void ReviveOSD()
{
while (OSD.resetIsBusy()) delay(100);
OSD.reset();
while (OSD.resetIsBusy()) delay(100);
setupMAX7456();
}
static uint32_t LastLoopTime = 0;
typedef void* (*fptr)();
static char tempSymbol[] = {0xB0, 0x00};
static char ESCSymbol[] = {0x7E, 0x00};
static const char crossHairSymbol[] = {0x11, 0x00};
static uint8_t code = 0;
static boolean menuActive = true;
static boolean menuWasActive = false;
extern void* MainMenu();
static void* activePage = (void*)MainMenu;
static boolean batterySelect = false;
static boolean shiftOSDactive = false;
static uint8_t activeMenuItem = 0;
static uint8_t stopWatch = 0x94;
static char batterySymbol[] = { 0x83, 0x88, 0x88, 0x89, 0x00 };
static uint8_t krSymbol[4] = { 0x9C, 0x9C, 0x9C, 0x9C };
static unsigned long krTime[4] = { 0, 0, 0, 0 };
static boolean saveSettings = false;
#ifdef UPDATE_FONT_ONLY
static boolean updateFont = true;
#else
static boolean updateFont = false;
#endif
static boolean updateFontComplete = false;
static boolean moveItems = false;
static uint8_t moveSelected = 0;
static unsigned long startMoveTime = 0;
static boolean setupNickname = false;
static const char charTable[] = { 0x20, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, 0x34,
0x35, 0x36, 0x37, 0x38, 0x39
};
static const uint8_t charTableSize = 37;
static uint8_t charSelected = 0;
static uint8_t charIndex = 1;
volatile bool timer1sec = false;
static unsigned long timer1secTime = 0;
static uint8_t currentDVItem = 0;
static uint16_t fcNotConnectedCount = 0;
static bool activeOSDItems[] = { true, true, true, true, true, true, true, true, true, true, true };
static uint8_t oldPrintCount = 0;
static uint8_t printCount = 0;
#ifdef BF32_MODE
static uint8_t telemetryMSP = 0;
static const uint8_t MAX_TELEMETRY_MSPS = 7;
static const uint8_t telemetryMSPs[MAX_TELEMETRY_MSPS] = { 105, 110, 119, 101, 128, 129, 134 }; //FIXME: Move define for MSPs
extern void mspRequest(uint8_t mspCommand);
static const unsigned long minLoop = 2500;
#else
static const unsigned long minLoop = 10000;
#endif
#ifdef DEBUG
static int16_t versionProto = 0;
#endif
static unsigned long _StartupTime = 0;
static boolean telemetryReceived = false;
extern void* MainMenu();
uint8_t findCharPos(char charToFind)
{
if (charToFind > 0x7A || charToFind < 0x20 || (charToFind > 0x20 && charToFind < 0x61)) return 1;
uint8_t i = 0;
while (charTable[i] != charToFind && i < charTableSize) i++;
if(i >= charTableSize) return 1;
return i;
}
void loop() {
uint8_t i = 0;
static uint8_t blink_i = 1;
unsigned long currentMillis = millis();
#ifdef IMPULSERC_VTX
/*if(oldvTxBand != vTxBand || oldvTxChannel != vTxChannel || changevTxTime > 0)
{
if(changevTxTime == 0)
{
changevTxTime = millis();
oldvTxBand = vTxBand;
oldvTxChannel = vTxChannel;
}
}
else
{*/
vtx_process_state(millis(), vTxBand, vTxChannel);
//}
#endif
if (_StartupTime == 0)
{
_StartupTime = millis();
}
if ((millis() - timer1secTime) > 500)
{
timer1secTime = millis();
timer1sec = !timer1sec;
}
if ((micros() - LastLoopTime) > minLoop)
{
LastLoopTime = micros();
#if !defined(FORCE_PAL) && !defined(FORCE_NTSC)
checkVideoMode();
#endif
#ifdef IMPULSERC_VTX
if (timer1sec)
{
vtx_set_power(armed ? vTxPower : 0);
}
#endif
#ifdef DEBUG
while (!OSD.notInVSync());
uint8_t debug_col = 8;
OSD.printInt16(debug_col, 8, (int16_t)analogRead(A6), 0, 0);
#endif
#ifndef UPDATE_FONT_ONLY
#ifdef BF32_MODE
mspRequest(telemetryMSPs[telemetryMSP]);
#else
NewSerial.write(0x20); // request telemetry
#endif
telemetryReceived = ReadTelemetry();
if (!telemetryReceived)
{
fcNotConnectedCount++;
#ifdef BF32_MODE
if(telemetryMSP == (MAX_TELEMETRY_MSPS-1)) //skipping MSP_EXTRA_ESC_DATA if it does not exist
{
telemetryReceived = true;
telemetryMSP = 0;
fcNotConnectedCount = 0;
}
#endif
}
else
{
fcNotConnectedCount = 0;
#ifdef BF32_MODE
telemetryMSP++;
if(telemetryMSP < MAX_TELEMETRY_MSPS)
{
telemetryReceived = false;
}
else telemetryMSP = 0;
#endif
}
#endif
if (fcNotConnectedCount <= 500 && !telemetryReceived) return;
while (!OSD.notInVSync());
#ifndef UPDATE_FONT_ONLY
if (fcNotConnectedCount > 500)
{
#ifdef BF32_MODE
static const char FC_NOT_CONNECTED_STR[] PROGMEM = ""no connection to fc"";
#else
static const char FC_NOT_CONNECTED_STR[] PROGMEM = ""no connection to kiss fc"";
#endif
OSD.printP(settings.COLS / 2 - strlen_P(FC_NOT_CONNECTED_STR) / 2, settings.ROWS / 2, FC_NOT_CONNECTED_STR);
triggerCleanScreen = true;
fcNotConnectedCount = 0;
return;
}
#endif
#ifdef IMPULSERC_VTX
/*if(changevTxTime > 0)
{
static const char CHANGE_CHANNELS_STR[] PROGMEM = ""changing vtx to "";
OSD.printP(settings.COLS/2 - (strlen_P(CHANGE_CHANNELS_STR)/2 + 5), 8, CHANGE_CHANNELS_STR);
OSD.printInt16(settings.COLS/2 - (strlen_P(CHANGE_CHANNELS_STR)/2 + 5) + strlen_P(CHANGE_CHANNELS_STR) + 1, 8, bandSymbols[vTxBand], (int16_t)vTxChannel, 0, 1, ""="");
OSD.printInt16(settings.COLS/2 - (strlen_P(CHANGE_CHANNELS_STR)/2 + 5) + strlen_P(CHANGE_CHANNELS_STR) + 5, 8, (int16_t)pgm_read_word(&vtx_frequencies[settings.m_vTxBand][settings.m_vTxChannel]), 0, 1, ""mhz"");
uint8_t timeLeft = (uint8_t)((6000 - (millis() - changevTxTime))/1000);
OSD.printInt16(settings.COLS/2 - 6, 9, ""in "", (int16_t)timeLeft, 0, 1, "" seconds"");
if(timeLeft < 1)
{
changevTxTime = 0;
cleanScreen();
}
}*/
vtx_flash_led(1);
#endif
if(triggerCleanScreen)
{
triggerCleanScreen = false;
cleanScreen();
}
if(oldPrintCount != printCount)
{
cleanScreen();
oldPrintCount = printCount;
}
if (settings.s.m_tempUnit == 1)
{
tempSymbol[0] = fixChar(0xB1);
}
else
{
tempSymbol[0] = fixChar(0xB0);
}
if(telemetryReceived) code = inputChecker.ProcessStickInputs(roll, pitch, yaw, armed);
if (armed == 0 && code & inputChecker.YAW_LONG_LEFT && code & inputChecker.ROLL_LEFT && code & inputChecker.PITCH_DOWN)
{
ReviveOSD();
}
if (armed == 0 && setupNickname)
{
static const char ROLL_UP_DOWN_CHAR_STR[] PROGMEM = ""use pitch/roll to set name"";
static const char YAW_LEFT_EXIT_STR[] PROGMEM = ""yaw left to exit"";
OSD.printP(settings.COLS / 2 - strlen_P(ROLL_UP_DOWN_CHAR_STR) / 2, settings.ROWS / 2 - 2, ROLL_UP_DOWN_CHAR_STR);
OSD.printP(settings.COLS / 2 - strlen_P(YAW_LEFT_EXIT_STR) / 2, settings.ROWS / 2 - 1, YAW_LEFT_EXIT_STR);
if (code & inputChecker.PITCH_UP)
{
if (charIndex == 0)
{
charIndex = charTableSize - 1;
}
else
{
charIndex--;
}
settingChanged = true;
}
if (code & inputChecker.PITCH_DOWN)
{
if (charIndex == charTableSize - 1)
{
charIndex = 0;
}
else
{
charIndex++;
}
settingChanged = true;
}
if (code & inputChecker.ROLL_LEFT && charSelected > 0)
{
charSelected--;
charIndex = findCharPos(settings.s.m_nickname[charSelected]);
}
if (code & inputChecker.ROLL_RIGHT && charSelected < CSettings::NICKNAME_STR_SIZE - 2)
{
charSelected++;
charIndex = findCharPos(settings.s.m_nickname[charSelected]);
}
settings.s.m_nickname[charSelected] = charTable[charIndex];
OSD.setCursor(settings.COLS / 2 - CSettings::NICKNAME_STR_SIZE / 2, settings.ROWS / 2);
for (i = 0; i < CSettings::NICKNAME_STR_SIZE - 1; i++)
{
if (i == charSelected && timer1sec)
{
OSD.print(fixChar(' '));
}
else
{
if (settings.s.m_nickname[i] == 0x00 && i == 0)
{
OSD.print(fixChar(charTable[charIndex]));
}
else
{
OSD.print(fixChar(settings.s.m_nickname[i]));
}
}
}
if (code & inputChecker.YAW_LEFT)
{
uint8_t nickEnd = 7;
while ((settings.s.m_nickname[nickEnd] == 0x00 || settings.s.m_nickname[nickEnd] == 0x20) && nickEnd > 0) nickEnd--;
settings.s.m_nickname[nickEnd + 1] = 0x00;
const char mustache[] = { 0x7F, 0x80, 0x81, 0x82, 0x00 };
const char secret[] = { 0x35, 0x37, 0x33, 0x33, 0x31, 0x33, 0x00 }; //573313
if(strcmp(settings.s.m_nickname, secret) == 0) strcpy(settings.s.m_nickname, mustache);
setupNickname = false;
cleanScreen();
}
else
{
return;
}
}
if (armed == 0 && moveItems)
{
for(i=0; i < settings.OSD_ITEMS_POS_SIZE; i++)
{
if(settings.m_OSDItems[i][1] >= settings.ROWS) settings.m_OSDItems[i][1] = settings.ROWS - 1;
}
if (startMoveTime == 0) startMoveTime = millis();
static const char ROLL_UP_DOWN_MOVE_STR[] PROGMEM = ""use pitch/roll to move"";
static const char YAW_LEFT_SELECT_STR[] PROGMEM = ""yaw left for next item"";
static const char YAW_LONG_LEFT_EXIT_STR[] PROGMEM = ""yaw long left to exit"";
if (millis() - startMoveTime < 5000)
{
OSD.printP(settings.COLS / 2 - strlen_P(ROLL_UP_DOWN_MOVE_STR) / 2, settings.ROWS / 2 - 1, ROLL_UP_DOWN_MOVE_STR);
OSD.printP(settings.COLS / 2 - strlen_P(YAW_LEFT_SELECT_STR) / 2, settings.ROWS / 2, YAW_LEFT_SELECT_STR);
OSD.printP(settings.COLS / 2 - strlen_P(YAW_LONG_LEFT_EXIT_STR) / 2, settings.ROWS / 2 + 1, YAW_LONG_LEFT_EXIT_STR);
}
if (code & inputChecker.YAW_LEFT)
{
OSD_ITEM_BLINK[moveSelected] = false;
moveSelected++;
if (moveSelected == CSettings::OSD_ITEMS_SIZE)
{
moveSelected = 0;
}
}
while(settings.s.m_DVchannel == 4 && !activeOSDItems[moveSelected])
{
moveSelected++;
if (moveSelected == CSettings::OSD_ITEMS_SIZE) moveSelected = 0;
}
OSD_ITEM_BLINK[moveSelected] = true;
uint8_t moveCount = 1;
uint8_t oldMoveSelected = moveSelected;
if (moveSelected > STOPW)
{
if(moveSelected > ESC4) moveSelected = 18 + (moveSelected - RSSI_);
else moveSelected = STOPW + (moveSelected - STOPW - 1) * 3 + 1;
if(moveSelected < RSSIp) moveCount = 3;
}
for (i = 0; i < moveCount; i++)
{
if (code & inputChecker.PITCH_UP)
{
if (settings.m_OSDItems[moveSelected][1] > 0)
{
settings.m_OSDItems[moveSelected][1]--;
cleanScreen();
settingChanged = true;
}
}
if (code & inputChecker.PITCH_DOWN)
{
if (settings.m_OSDItems[moveSelected][1] < settings.ROWS - 1)
{
settings.m_OSDItems[moveSelected][1]++;
cleanScreen();
settingChanged = true;
}
}
if (code & inputChecker.ROLL_LEFT)
{
if (settings.m_OSDItems[moveSelected][0] > 0)
{
settings.m_OSDItems[moveSelected][0]--;
cleanScreen();
settingChanged = true;
}
}
if (code & inputChecker.ROLL_RIGHT)
{
if (settings.m_OSDItems[moveSelected][0] < settings.COLS - 1 - settings.s.m_goggle && itemLengthOK[moveSelected] == 0)
{
settings.m_OSDItems[moveSelected][0]++;
cleanScreen();
settingChanged = true;
}
}
moveSelected++;
}
moveSelected = oldMoveSelected;
if (code & inputChecker.YAW_LONG_LEFT)
{
OSD_ITEM_BLINK[moveSelected] = false;
settings.SetupPPMs(DV_PPMs);
moveItems = false;
menuActive = true;
startMoveTime = 0;
resetBlinking();
cleanScreen();
}
}
if (updateFontComplete)
{
static const char FONT_COMPLETE_STR[] PROGMEM = ""font updated"";
OSD.printP(settings.COLS / 2 - strlen_P(FONT_COMPLETE_STR) / 2, settings.ROWS / 2, FONT_COMPLETE_STR);
#ifdef UPDATE_FONT_ONLY
while(1) delay(1000);
#else
delay(3000);
updateFontComplete = false;
cleanScreen();
#endif
}
if (updateFont)
{
delay(3000);
cleanScreen();
OSD.updateFont(serialBuf);
updateFont = false;
setupMAX7456();
updateFontComplete = true;
return;
}
if (shiftOSDactive && armed == 0)
{
static const char OSD_SHIFT_STR[] PROGMEM = ""roll/pitch to center osd"";
OSD.printP(settings.COLS / 2 - strlen_P(OSD_SHIFT_STR) / 2, settings.ROWS / 2 - 1, OSD_SHIFT_STR);
static const char OSD_SHIFT_EXIT_STR[] PROGMEM = ""yaw left to exit"";
OSD.printP(settings.COLS / 2 - strlen_P(OSD_SHIFT_EXIT_STR) / 2, settings.ROWS / 2, OSD_SHIFT_EXIT_STR);
boolean changedOffset = false;
if (code & inputChecker.ROLL_RIGHT)
{
settings.s.m_xOffset++;
changedOffset = true;
}
if (code & inputChecker.ROLL_LEFT)
{
settings.s.m_xOffset--;
changedOffset = true;
}
if (code & inputChecker.PITCH_UP)
{
settings.s.m_yOffset--;
changedOffset = true;
}
if (code & inputChecker.PITCH_DOWN)
{
settings.s.m_yOffset++;
changedOffset = true;
}
settingChanged |= changedOffset;
if (changedOffset)
{
cleanScreen();
OSD.setTextOffset(settings.s.m_xOffset, settings.s.m_yOffset);
}
if (code & inputChecker.YAW_LEFT)
{
shiftOSDactive = false;
menuActive = true;
cleanScreen();
}
}
if (armed == 0 && batterySelect)
{
if (!showBat)
{
cleanScreen();
showBat = true;
}
if ((code & inputChecker.ROLL_LEFT) && settings.s.m_activeBattery > 0)
{
settings.s.m_activeBattery--;
settings.FixBatWarning();
settingChanged = true;
}
if ((code & inputChecker.ROLL_RIGHT) && settings.s.m_activeBattery < 3)
{
settings.s.m_activeBattery++;
settings.FixBatWarning();
settingChanged = true;
}
if ((code & inputChecker.PITCH_UP) && settings.s.m_batMAH[settings.s.m_activeBattery] < 32000)
{
settings.s.m_batMAH[settings.s.m_activeBattery] += BAT_MAH_INCREMENT;
settings.FixBatWarning();
settingChanged = true;
}
if ((code & inputChecker.PITCH_DOWN) && settings.s.m_batMAH[settings.s.m_activeBattery] > 300)
{
settings.s.m_batMAH[settings.s.m_activeBattery] -= BAT_MAH_INCREMENT;
settings.FixBatWarning();
settingChanged = true;
}
static const char BATTERY_STR[] PROGMEM = ""battery "";
uint8_t batCol = settings.COLS / 2 - (strlen_P(BATTERY_STR) + 1) / 2;
OSD.printInt16P(batCol, settings.ROWS / 2 - 1, BATTERY_STR, settings.s.m_activeBattery + 1, 0, 1);
batCol = settings.COLS / 2 - 3;
OSD.printInt16(batCol, settings.ROWS / 2, settings.s.m_batMAH[settings.s.m_activeBattery], 0, 1, ""mah"", 2);
static const char WARN_STR[] PROGMEM = ""warn at "";
batCol = settings.COLS / 2 - (strlen_P(WARN_STR) + 6) / 2;
OSD.printInt16P(batCol, settings.ROWS / 2 + 1, WARN_STR, settings.s.m_batWarningMAH, 0, 1, ""mah"", 2);
if (batterySelect)
{
static const char YAW_LEFT_STR[] PROGMEM = ""yaw left to go back"";
OSD.printP(settings.COLS / 2 - strlen_P(YAW_LEFT_STR) / 2, settings.ROWS / 2 + 2, YAW_LEFT_STR);
}
if (batterySelect && yaw < 250)
{
batterySelect = false;
}
return;
}
else
{
if (showBat)
{
cleanScreen();
showBat = false;
}
}
if (saveSettings && settingChanged && !shiftOSDactive)
{
settings.WriteSettings();
settingChanged = false;
saveSettings = false;
static const char SETTINGS_SAVED_STR[] PROGMEM = ""settings saved"";
OSD.printP(settings.COLS / 2 - strlen_P(SETTINGS_SAVED_STR) / 2, settings.ROWS / 2, SETTINGS_SAVED_STR);
delay(1500);
cleanScreen();
}
if (armed == 0 && ((code & inputChecker.YAW_LONG_LEFT) || menuActive))
{
if (!menuActive)
{
menuActive = true;
cleanScreen();
activePage = (void*)MainMenu;
}
fptr temp = (fptr) activePage;
activePage = (void*)temp();
return;
}
else
{
if (menuWasActive)
{
menuWasActive = false;
activeMenuItem = 0;
cleanScreen();
}
}
if (armed == 0 && armedOnce && last_Aux_Val != AuxChanVals[settings.s.m_DVchannel])
{
DV_change_time = millis();
last_Aux_Val = AuxChanVals[settings.s.m_DVchannel];
}
printCount = 0;
uint8_t TMPmargin = 0;
uint8_t CurrentMargin = 0;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_RC_THROTTLE])
{
printCount++;
activeOSDItems[THROTTLE] = true;
if (OSD_ITEM_BLINK[THROTTLE]) OSD.blink1sec();
itemLengthOK[THROTTLE] = OSD.printInt16( settings.m_OSDItems[THROTTLE][0], settings.m_OSDItems[THROTTLE][1], throttle, 0, 1, ""%"", 2, THROTTLEp);
//ESCmarginTop = 1;
}
else activeOSDItems[THROTTLE] = false;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_NICKNAME])
{
printCount++;
activeOSDItems[NICKNAME] = true;
uint8_t nickBlanks = 0;
itemLengthOK[NICKNAME] = OSD.checkPrintLength(settings.m_OSDItems[NICKNAME][0], settings.m_OSDItems[NICKNAME][1], (uint8_t)strlen(settings.s.m_nickname), nickBlanks, NICKNAMEp);
if (OSD_ITEM_BLINK[NICKNAME] && timer1sec)
{
OSD.printSpaces(strlen(settings.s.m_nickname));
}
else
{
OSD.print( fixStr(settings.s.m_nickname) );
}
}
else activeOSDItems[NICKNAME] = false;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_COMB_CURRENT])
{
printCount++;
activeOSDItems[AMPS] = true;
if(settings.s.m_wattMeter == 0)
{
if (OSD_ITEM_BLINK[AMPS]) OSD.blink1sec();
itemLengthOK[AMPS] = OSD.printInt16(settings.m_OSDItems[AMPS][0], settings.m_OSDItems[AMPS][1], current, 1, 0, ""a"", 1, AMPSp);
}
else
{
if(settings.s.m_displaySymbols == 0 || settings.m_IconSettings[WATT_ICON] == 0)
{
if (OSD_ITEM_BLINK[AMPS]) OSD.blink1sec();
itemLengthOK[AMPS] = OSD.printInt16(settings.m_OSDItems[AMPS][0], settings.m_OSDItems[AMPS][1], (int16_t)999, 1, 0, ""w"", 1, AMPSp);
}
else
{
char finalMeter1[] = { 0xEB, 0xEC, 0x00 };
char finalMeter2[] = { 0xE1, 0xE2, 0x00 };
if(settings.s.m_wattMeter == 2)
{
finalMeter1[0] = 0x01;
finalMeter1[1] = 0x02;
finalMeter2[0] = 0x09;
finalMeter2[1] = 0x0A;
}
int8_t wattRow = settings.m_OSDItems[AMPS][1]-1;
if(wattRow < 0) wattRow = 0;
uint8_t ampBlanks = 0;
itemLengthOK[AMPS] = OSD.checkPrintLength(settings.m_OSDItems[AMPS][0], wattRow, (uint8_t)strlen(finalMeter1), ampBlanks, AMPSp);
if (OSD_ITEM_BLINK[AMPS] && timer1sec)
{
OSD.printSpaces(2);
OSD.checkPrintLength(settings.m_OSDItems[AMPS][0], wattRow+1, (uint8_t)strlen(finalMeter1), ampBlanks, AMPSp);
OSD.printSpaces(2);
}
else
{
OSD.print(finalMeter1);
OSD.checkPrintLength(settings.m_OSDItems[AMPS][0], wattRow+1, (uint8_t)strlen(finalMeter1), ampBlanks, AMPSp);
OSD.print(finalMeter2);
}
}
}
}
else activeOSDItems[AMPS] = false;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_LIPO_VOLTAGE])
{
printCount++;
activeOSDItems[VOLTAGE] = true;
if (OSD_ITEM_BLINK[VOLTAGE]) OSD.blink1sec();
itemLengthOK[VOLTAGE] = OSD.printInt16( settings.m_OSDItems[VOLTAGE][0], settings.m_OSDItems[VOLTAGE][1], LipoVoltage / 10, 1, 1, ""v"", 1, VOLTAGEp);
}
else activeOSDItems[VOLTAGE] = false;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_MA_CONSUMPTION])
{
printCount++;
activeOSDItems[MAH] = true;
if (settings.s.m_displaySymbols == 1 && settings.m_IconSettings[MAH_ICON] == 1)
{
uint8_t batCount = (LipoMAH + previousMAH) / settings.m_batSlice;
uint8_t batStatus = 0x88;
while (batCount > 4)
{
batStatus--;
batCount--;
}
batterySymbol[2] = (char)batStatus;
batStatus = 0x88;
while (batCount > 0)
{
batStatus--;
batCount--;
}
batterySymbol[1] = (char)batStatus;
uint8_t mahBlanks = 0;
itemLengthOK[MAH] = OSD.checkPrintLength(settings.m_OSDItems[MAH][0], settings.m_OSDItems[MAH][1], 4, mahBlanks, MAHp);
if (OSD_ITEM_BLINK[MAH] && timer1sec)
{
OSD.printSpaces(4);
}
else
{
OSD.print(batterySymbol);
}
}
else
{
if (OSD_ITEM_BLINK[MAH]) OSD.blink1sec();
itemLengthOK[MAH] = OSD.printInt16(settings.m_OSDItems[MAH][0], settings.m_OSDItems[MAH][1], LipoMAH + previousMAH, 0, 1, ""mah"", 0, MAHp);
}
}
else activeOSDItems[MAH] = false;
if (settings.s.m_displaySymbols == 1 && settings.m_IconSettings[ESC_ICON] == 1)
{
ESCSymbol[0] = fixChar((char)0x7E);
}
else
{
ESCSymbol[0] = 0x00;
}
bool displayAnyESCData = false;
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_ESC_KRPM])
{
printCount++;
displayAnyESCData = true;
static char KR[4];
if (settings.s.m_displaySymbols == 1 && settings.m_IconSettings[PROPS_ICON] == 1)
{
for (i = 0; i < 4; i++)
{
if (millis() - krTime[i] > (10000 / motorKERPM[i]))
{
krTime[i] = millis();
if ((i + 1) % 2 == 0)
{
krSymbol[i]--;
}
else
{
krSymbol[i]++;
}
if (krSymbol[i] > 0xA3)
{
krSymbol[i] = 0x9C;
}
if (krSymbol[i] < 0x9C)
{
krSymbol[i] = 0xA3;
}
}
KR[i] = (char)krSymbol[i];
}
uint8_t ESCkrBlanks = 0;
itemLengthOK[ESC1kr] = OSD.checkPrintLength(settings.m_OSDItems[ESC1kr][0], settings.m_OSDItems[ESC1kr][1], 1, ESCkrBlanks, ESC1kr);
if (OSD_ITEM_BLINK[ESC1] && timer1sec) OSD.print(' ');
else OSD.print(KR[0]);
itemLengthOK[ESC2kr] = OSD.checkPrintLength(settings.m_OSDItems[ESC2kr][0], settings.m_OSDItems[ESC2kr][1], 1, ESCkrBlanks, ESC2kr);
if (OSD_ITEM_BLINK[ESC2] && timer1sec) OSD.print(' ');
else OSD.print(KR[1]);
itemLengthOK[ESC3kr] = OSD.checkPrintLength(settings.m_OSDItems[ESC3kr][0], settings.m_OSDItems[ESC3kr][1], 1, ESCkrBlanks, ESC3kr);
if (OSD_ITEM_BLINK[ESC3] && timer1sec) OSD.print(' ');
else OSD.print(KR[2]);
itemLengthOK[ESC4kr] = OSD.checkPrintLength(settings.m_OSDItems[ESC4kr][0], settings.m_OSDItems[ESC4kr][1], 1, ESCkrBlanks, ESC4kr);
if (OSD_ITEM_BLINK[ESC4] && timer1sec) OSD.print(' ');
else OSD.print(KR[3]);
}
else
{
static char KR2[3];
KR2[0] = 'k';
KR2[1] = 'r';
KR2[2] = 0x00;
if (OSD_ITEM_BLINK[ESC1]) OSD.blink1sec();
itemLengthOK[ESC1kr] = OSD.printInt16(settings.m_OSDItems[ESC1kr][0], settings.m_OSDItems[ESC1kr][1], motorKERPM[0], 1, 1, KR2, 1, ESC1kr);
if (OSD_ITEM_BLINK[ESC2]) OSD.blink1sec();
itemLengthOK[ESC2kr] = OSD.printInt16(settings.m_OSDItems[ESC2kr][0], settings.m_OSDItems[ESC2kr][1], motorKERPM[1], 1, 0, KR2, 1, ESC2kr);
if (OSD_ITEM_BLINK[ESC3]) OSD.blink1sec();
itemLengthOK[ESC3kr] = OSD.printInt16(settings.m_OSDItems[ESC3kr][0], settings.m_OSDItems[ESC3kr][1], motorKERPM[2], 1, 0, KR2, 1, ESC3kr);
if (OSD_ITEM_BLINK[ESC4]) OSD.blink1sec();
itemLengthOK[ESC4kr] = OSD.printInt16( settings.m_OSDItems[ESC4kr][0], settings.m_OSDItems[ESC4kr][1], motorKERPM[3], 1, 1, KR2, 1, ESC4kr);
}
TMPmargin++;
CurrentMargin++;
}
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_ESC_CURRENT])
{
printCount++;
displayAnyESCData = true;
static char ampESC[] = { 'a', 0x7E, 0x00};
ampESC[1] = ESCSymbol[0];
if (OSD_ITEM_BLINK[ESC1]) OSD.blink1sec();
itemLengthOK[ESC1voltage] = OSD.printInt16(settings.m_OSDItems[ESC1voltage][0], settings.m_OSDItems[ESC1voltage][1] + CurrentMargin, motorCurrent[0], 1, 1, ""a"", 1, ESC1voltage, ESCSymbol);
if (OSD_ITEM_BLINK[ESC2]) OSD.blink1sec();
itemLengthOK[ESC2voltage] = OSD.printInt16(settings.m_OSDItems[ESC2voltage][0], settings.m_OSDItems[ESC2voltage][1] + CurrentMargin, motorCurrent[1], 1, 0, ampESC, 1, ESC2voltage);
if (OSD_ITEM_BLINK[ESC3]) OSD.blink1sec();
itemLengthOK[ESC3voltage] = OSD.printInt16(settings.m_OSDItems[ESC3voltage][0], settings.m_OSDItems[ESC3voltage][1] - CurrentMargin, motorCurrent[2], 1, 0, ampESC, 1, ESC3voltage);
if (OSD_ITEM_BLINK[ESC4]) OSD.blink1sec();
itemLengthOK[ESC4voltage] = OSD.printInt16(settings.m_OSDItems[ESC4voltage][0], settings.m_OSDItems[ESC4voltage][1] - CurrentMargin, motorCurrent[3], 1 , 1, ""a"", 1, ESC4voltage, ESCSymbol);
TMPmargin++;
}
if (AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_ESC_TEMPERATURE])
{
printCount++;
displayAnyESCData = true;
static char tempESC[] = { tempSymbol[0], 0x7E, 0x00};
tempESC[0] = tempSymbol[0];
tempESC[1] = ESCSymbol[0];
if (OSD_ITEM_BLINK[ESC1]) OSD.blink1sec();
itemLengthOK[ESC1temp] = OSD.printInt16( settings.m_OSDItems[ESC1temp][0], settings.m_OSDItems[ESC1temp][1] + TMPmargin, ESCTemps[0], 0, 1, tempSymbol, 1, ESC1temp, ESCSymbol);
if (OSD_ITEM_BLINK[ESC2]) OSD.blink1sec();
itemLengthOK[ESC2temp] = OSD.printInt16(settings.m_OSDItems[ESC2temp][0], settings.m_OSDItems[ESC2temp][1] + TMPmargin, ESCTemps[1], 0, 0, tempESC, 1, ESC2temp);
if (OSD_ITEM_BLINK[ESC3]) OSD.blink1sec();
itemLengthOK[ESC3temp] = OSD.printInt16(settings.m_OSDItems[ESC3temp][0], settings.m_OSDItems[ESC3temp][1] - TMPmargin, ESCTemps[2], 0, 0, tempESC, 1, ESC3temp);
if (OSD_ITEM_BLINK[ESC4]) OSD.blink1sec();
itemLengthOK[ESC4temp] = OSD.printInt16(settings.m_OSDItems[ESC4temp][0], settings.m_OSDItems[ESC4temp][1] - TMPmargin, ESCTemps[3], 0, 1, tempSymbol, 1, ESC4temp, ESCSymbol);
}
for(i=ESC1; i DV_PPMs[DISPLAY_TIMER])
{
printCount++;
activeOSDItems[STOPW] = true;
char stopWatchStr[] = { 0x00, 0x00 };
if (settings.s.m_displaySymbols == 1 && settings.m_IconSettings[TIMER_ICON] == 1)
{
if (time - old_time > 1000)
{
stopWatch++;
old_time = time;
}
if (stopWatch > 0x9B)
{
stopWatch = 0x94;
}
stopWatchStr[0] = stopWatch;
}
else
{
stopWatchStr[0] = 0x00;
}
if (OSD_ITEM_BLINK[STOPW]) OSD.blink1sec();
OSD.printTime(settings.m_OSDItems[STOPW][0], settings.m_OSDItems[STOPW][1], time, stopWatchStr, STOPWp);
}
else activeOSDItems[STOPW] = false;
if((settings.s.m_RSSIchannel > -1 && AuxChanVals[settings.s.m_DVchannel] > DV_PPMs[DISPLAY_RSSI]) || (moveItems && settings.s.m_DVchannel < 4))
{
printCount++;
activeOSDItems[RSSI_] = true;
if (settings.s.m_displaySymbols == 1 && settings.m_IconSettings[RSSI_ICON] == 1)
{
static char rssiIcon[] = { 0x14, 0x17, 0x00 };
uint8_t zeroBlanks = 0;
itemLengthOK[RSSIp] = OSD.checkPrintLength(settings.m_OSDItems[RSSIp][0], settings.m_OSDItems[RSSIp][1], 2, zeroBlanks, RSSIp);
if (OSD_ITEM_BLINK[RSSI_] && timer1sec) OSD.printSpaces(2);
else OSD.print(rssiIcon);
}
else
{
itemLengthOK[RSSIp] = OSD.printInt16(settings.m_OSDItems[RSSIp][0], settings.m_OSDItems[RSSIp][1], (int16_t)0, 0, 1, ""db"", 0, RSSIp);
if (OSD_ITEM_BLINK[RSSI_] && timer1sec) OSD.printSpaces(3);
}
}
else activeOSDItems[RSSI_] = false;
if(settings.s.m_crossHair && !moveItems && !shiftOSDactive)
{
int8_t crossOffset = 0;
if(settings.s.m_crossHair > 1) crossOffset = (int8_t)settings.s.m_crossHair - (int8_t)5;
OSD.setCursor(settings.COLS/2 - 1, (int8_t)(settings.ROWS/2) + crossOffset);
OSD.print(crossHairSymbol);
}
if (DV_change_time > 0 && (millis() - DV_change_time) > 3000 && last_Aux_Val == AuxChanVals[settings.s.m_DVchannel])
{
DV_change_time = 0;
cleanScreen();
}
if (!correctItemsOnce && moveItems)
{
for (i = 0; i < CSettings::OSD_ITEMS_POS_SIZE; i++)
{
if (itemLengthOK[i] > 0)
{
settings.m_OSDItems[i][0] = itemLengthOK[i];
}
}
correctItemsOnce = true;
}
/*bool displaySettingsChanged = settings.m_oldDisplaySymbols != settings.m_displaySymbols;
if(displaySettingsChanged)
{
cleanScreen();
settings.fixColBorders();
}*/
}
}
#ifdef DEBUG
int freeRam() {
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
#endif
",12360,False,2339.407455382999,median
"###############################################################################
# Copyright 2019 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material (""Material"") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# ""License""), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 5, 0x90
POLY:
.quad 0x1, 0xC200000000000000
TWOONE:
.quad 0x1, 0x100000000
SHUF_CONST:
.quad 0x8090a0b0c0d0e0f, 0x1020304050607
MASK1:
.quad 0xffffffffffffffff, 0x0
MASK2:
.quad 0x0, 0xffffffffffffffff
INC_1:
.quad 1,0
.p2align 5, 0x90
.globl _e9_AesGcmPrecompute_avx
_e9_AesGcmPrecompute_avx:
movdqu (%rsi), %xmm0
pshufb SHUF_CONST(%rip), %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm0
psrlq $(63), %xmm4
movdqa %xmm4, %xmm3
pslldq $(8), %xmm4
psrldq $(8), %xmm3
por %xmm4, %xmm0
pshufd $(36), %xmm3, %xmm4
pcmpeqd TWOONE(%rip), %xmm4
pand POLY(%rip), %xmm4
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm1
pshufd $(78), %xmm1, %xmm5
pshufd $(78), %xmm0, %xmm3
pxor %xmm1, %xmm5
pxor %xmm0, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm1, %xmm4
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm0, %xmm4
pxor %xmm1, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm3
movdqa %xmm1, %xmm5
movdqa %xmm1, %xmm15
psllq $(63), %xmm3
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm3
pxor %xmm15, %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm1
pxor %xmm3, %xmm4
movdqa %xmm1, %xmm5
psrlq $(5), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm1
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm5
pshufd $(78), %xmm1, %xmm3
pxor %xmm2, %xmm5
pxor %xmm1, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm2, %xmm4
pclmulqdq $(0), %xmm1, %xmm2
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm1, %xmm4
pxor %xmm2, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm3
movdqa %xmm2, %xmm5
movdqa %xmm2, %xmm15
psllq $(63), %xmm3
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm3
pxor %xmm15, %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm2, %xmm5
psrlq $(5), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm2
pxor %xmm4, %xmm2
movdqu %xmm0, (%rdi)
movdqu %xmm1, (16)(%rdi)
movdqu %xmm2, (32)(%rdi)
vzeroupper
ret
.p2align 5, 0x90
.globl _e9_AesGcmMulGcm_avx
_e9_AesGcmMulGcm_avx:
movdqa (%rdi), %xmm0
pshufb SHUF_CONST(%rip), %xmm0
movdqa (%rsi), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm15
psllq $(63), %xmm2
psllq $(62), %xmm4
psllq $(57), %xmm15
pxor %xmm4, %xmm2
pxor %xmm15, %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
pshufb SHUF_CONST(%rip), %xmm0
movdqa %xmm0, (%rdi)
vzeroupper
ret
.p2align 5, 0x90
.globl _e9_AesGcmAuth_avx
_e9_AesGcmAuth_avx:
movdqa (%rdi), %xmm0
pshufb SHUF_CONST(%rip), %xmm0
movdqa (%rcx), %xmm1
movslq %edx, %rdx
.p2align 5, 0x90
.Lauth_loopgas_3:
movdqu (%rsi), %xmm2
pshufb SHUF_CONST(%rip), %xmm2
add $(16), %rsi
pxor %xmm2, %xmm0
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm15
psllq $(63), %xmm2
psllq $(62), %xmm4
psllq $(57), %xmm15
pxor %xmm4, %xmm2
pxor %xmm15, %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
sub $(16), %rdx
jnz .Lauth_loopgas_3
pshufb SHUF_CONST(%rip), %xmm0
movdqa %xmm0, (%rdi)
vzeroupper
ret
.p2align 5, 0x90
.globl _e9_AesGcmEnc_avx
_e9_AesGcmEnc_avx:
push %rbx
sub $(128), %rsp
mov (152)(%rsp), %rax
mov (160)(%rsp), %rbx
mov (144)(%rsp), %rcx
movdqa SHUF_CONST(%rip), %xmm4
movdqu (%rax), %xmm0
movdqu (%rbx), %xmm1
movdqu (%rcx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%rsp)
movdqa %xmm1, (16)(%rsp)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%rsp)
movdqa %xmm1, (48)(%rsp)
movdqa %xmm1, (64)(%rsp)
movdqa %xmm1, (80)(%rsp)
mov (168)(%rsp), %rbx
movdqa (32)(%rbx), %xmm10
pshufd $(78), %xmm10, %xmm9
pxor %xmm10, %xmm9
movdqa %xmm9, (96)(%rsp)
movslq %edx, %rdx
mov %r9, %rcx
mov %rdx, %rax
and $(63), %rax
and $(-64), %rdx
jz .Lsingle_block_procgas_4
.p2align 5, 0x90
.Lblks4_loopgas_4:
movdqa INC_1(%rip), %xmm6
movdqa SHUF_CONST(%rip), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm6, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm6, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm6, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm6, %xmm4
movdqa %xmm4, (%rsp)
movdqa (%rcx), %xmm0
mov %rcx, %r10
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (16)(%r10), %xmm0
add $(16), %r10
mov %r8d, %r11d
sub $(1), %r11
.p2align 5, 0x90
.Lcipher4_loopgas_4:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (16)(%r10), %xmm0
add $(16), %r10
dec %r11
jnz .Lcipher4_loopgas_4
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%rsp), %xmm0
movdqa %xmm4, (16)(%rsp)
movdqu (%rsi), %xmm4
movdqu (16)(%rsi), %xmm5
movdqu (32)(%rsi), %xmm6
movdqu (48)(%rsi), %xmm7
add $(64), %rsi
pxor %xmm4, %xmm0
movdqu %xmm0, (%rdi)
pshufb SHUF_CONST(%rip), %xmm0
pxor (32)(%rsp), %xmm0
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%rdi)
pshufb SHUF_CONST(%rip), %xmm1
pxor (48)(%rsp), %xmm1
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%rdi)
pshufb SHUF_CONST(%rip), %xmm2
pxor (64)(%rsp), %xmm2
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%rdi)
pshufb SHUF_CONST(%rip), %xmm3
pxor (80)(%rsp), %xmm3
add $(64), %rdi
cmp $(64), %rdx
je .Lcombine_hashgas_4
movdqa MASK1(%rip), %xmm14
pshufd $(78), %xmm0, %xmm6
movdqa %xmm0, %xmm5
pxor %xmm0, %xmm6
pclmulqdq $(0), %xmm10, %xmm0
pshufd $(78), %xmm1, %xmm13
movdqa %xmm1, %xmm12
pxor %xmm1, %xmm13
pclmulqdq $(17), %xmm10, %xmm5
pclmulqdq $(0), %xmm9, %xmm6
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
pshufd $(78), %xmm6, %xmm4
movdqa %xmm4, %xmm6
pand MASK2(%rip), %xmm4
pand %xmm14, %xmm6
pxor %xmm4, %xmm0
pxor %xmm6, %xmm5
movdqa %xmm0, %xmm4
psllq $(1), %xmm0
pclmulqdq $(0), %xmm10, %xmm1
pxor %xmm4, %xmm0
psllq $(5), %xmm0
pxor %xmm4, %xmm0
psllq $(57), %xmm0
pshufd $(78), %xmm0, %xmm6
movdqa %xmm6, %xmm0
pclmulqdq $(17), %xmm10, %xmm12
pand %xmm14, %xmm6
pand MASK2(%rip), %xmm0
pxor %xmm4, %xmm0
pxor %xmm6, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm0
pclmulqdq $(0), %xmm9, %xmm13
pxor %xmm6, %xmm0
psrlq $(1), %xmm0
pxor %xmm6, %xmm0
psrlq $(1), %xmm0
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
pxor %xmm1, %xmm13
pxor %xmm12, %xmm13
pshufd $(78), %xmm13, %xmm11
movdqa %xmm11, %xmm13
pand MASK2(%rip), %xmm11
pand %xmm14, %xmm13
pxor %xmm11, %xmm1
pxor %xmm13, %xmm12
movdqa %xmm1, %xmm11
movdqa %xmm1, %xmm13
movdqa %xmm1, %xmm15
psllq $(63), %xmm11
psllq $(62), %xmm13
psllq $(57), %xmm15
pxor %xmm13, %xmm11
pxor %xmm15, %xmm11
movdqa %xmm11, %xmm13
pslldq $(8), %xmm13
psrldq $(8), %xmm11
pxor %xmm13, %xmm1
pxor %xmm11, %xmm12
movdqa %xmm1, %xmm13
psrlq $(5), %xmm13
pxor %xmm1, %xmm13
psrlq $(1), %xmm13
pxor %xmm1, %xmm13
psrlq $(1), %xmm13
pxor %xmm13, %xmm1
pxor %xmm12, %xmm1
pshufd $(78), %xmm2, %xmm6
movdqa %xmm2, %xmm5
pxor %xmm2, %xmm6
pclmulqdq $(0), %xmm10, %xmm2
pshufd $(78), %xmm3, %xmm13
movdqa %xmm3, %xmm12
pxor %xmm3, %xmm13
pclmulqdq $(17), %xmm10, %xmm5
pclmulqdq $(0), %xmm9, %xmm6
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
pshufd $(78), %xmm6, %xmm4
movdqa %xmm4, %xmm6
pand MASK2(%rip), %xmm4
pand %xmm14, %xmm6
pxor %xmm4, %xmm2
pxor %xmm6, %xmm5
movdqa %xmm2, %xmm4
psllq $(1), %xmm2
pclmulqdq $(0), %xmm10, %xmm3
pxor %xmm4, %xmm2
psllq $(5), %xmm2
pxor %xmm4, %xmm2
psllq $(57), %xmm2
pshufd $(78), %xmm2, %xmm6
movdqa %xmm6, %xmm2
pclmulqdq $(17), %xmm10, %xmm12
pand %xmm14, %xmm6
pand MASK2(%rip), %xmm2
pxor %xmm4, %xmm2
pxor %xmm6, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm2
pclmulqdq $(0), %xmm9, %xmm13
pxor %xmm6, %xmm2
psrlq $(1), %xmm2
pxor %xmm6, %xmm2
psrlq $(1), %xmm2
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pxor %xmm3, %xmm13
pxor %xmm12, %xmm13
pshufd $(78), %xmm13, %xmm11
movdqa %xmm11, %xmm13
pand MASK2(%rip), %xmm11
pand %xmm14, %xmm13
pxor %xmm11, %xmm3
pxor %xmm13, %xmm12
movdqa %xmm3, %xmm11
movdqa %xmm3, %xmm13
movdqa %xmm3, %xmm15
psllq $(63), %xmm11
psllq $(62), %xmm13
psllq $(57), %xmm15
pxor %xmm13, %xmm11
pxor %xmm15, %xmm11
movdqa %xmm11, %xmm13
pslldq $(8), %xmm13
psrldq $(8), %xmm11
pxor %xmm13, %xmm3
pxor %xmm11, %xmm12
movdqa %xmm3, %xmm13
psrlq $(5), %xmm13
pxor %xmm3, %xmm13
psrlq $(1), %xmm13
pxor %xmm3, %xmm13
psrlq $(1), %xmm13
pxor %xmm13, %xmm3
pxor %xmm12, %xmm3
movdqa %xmm0, (32)(%rsp)
movdqa %xmm1, (48)(%rsp)
movdqa %xmm2, (64)(%rsp)
movdqa %xmm3, (80)(%rsp)
sub $(64), %rdx
movdqa (%rsp), %xmm0
cmp $(64), %rdx
jge .Lblks4_loopgas_4
.Lcombine_hashgas_4:
movdqa (%rbx), %xmm8
movdqa (16)(%rbx), %xmm9
pshufd $(78), %xmm0, %xmm5
pshufd $(78), %xmm10, %xmm6
pxor %xmm0, %xmm5
pxor %xmm10, %xmm6
pclmulqdq $(0), %xmm6, %xmm5
movdqa %xmm0, %xmm4
pclmulqdq $(0), %xmm10, %xmm0
pxor %xmm6, %xmm6
pclmulqdq $(17), %xmm10, %xmm4
pxor %xmm0, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm6
pslldq $(8), %xmm5
pxor %xmm6, %xmm4
pxor %xmm5, %xmm0
movdqa %xmm0, %xmm6
movdqa %xmm0, %xmm5
movdqa %xmm0, %xmm15
psllq $(63), %xmm6
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm6
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm6
pxor %xmm5, %xmm0
pxor %xmm6, %xmm4
movdqa %xmm0, %xmm5
psrlq $(5), %xmm5
pxor %xmm0, %xmm5
psrlq $(1), %xmm5
pxor %xmm0, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm0
pxor %xmm4, %xmm0
pshufd $(78), %xmm1, %xmm5
pshufd $(78), %xmm9, %xmm6
pxor %xmm1, %xmm5
pxor %xmm9, %xmm6
pclmulqdq $(0), %xmm6, %xmm5
movdqa %xmm1, %xmm4
pclmulqdq $(0), %xmm9, %xmm1
pxor %xmm6, %xmm6
pclmulqdq $(17), %xmm9, %xmm4
pxor %xmm1, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm6
pslldq $(8), %xmm5
pxor %xmm6, %xmm4
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm6
movdqa %xmm1, %xmm5
movdqa %xmm1, %xmm15
psllq $(63), %xmm6
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm6
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm6
pxor %xmm5, %xmm1
pxor %xmm6, %xmm4
movdqa %xmm1, %xmm5
psrlq $(5), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm1
pxor %xmm4, %xmm1
pshufd $(78), %xmm2, %xmm5
pshufd $(78), %xmm8, %xmm6
pxor %xmm2, %xmm5
pxor %xmm8, %xmm6
pclmulqdq $(0), %xmm6, %xmm5
movdqa %xmm2, %xmm4
pclmulqdq $(0), %xmm8, %xmm2
pxor %xmm6, %xmm6
pclmulqdq $(17), %xmm8, %xmm4
pxor %xmm2, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm6
pslldq $(8), %xmm5
pxor %xmm6, %xmm4
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm6
movdqa %xmm2, %xmm5
movdqa %xmm2, %xmm15
psllq $(63), %xmm6
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm6
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm6
pxor %xmm5, %xmm2
pxor %xmm6, %xmm4
movdqa %xmm2, %xmm5
psrlq $(5), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm2
pxor %xmm4, %xmm2
pxor %xmm1, %xmm3
pxor %xmm2, %xmm3
pshufd $(78), %xmm3, %xmm5
pshufd $(78), %xmm8, %xmm6
pxor %xmm3, %xmm5
pxor %xmm8, %xmm6
pclmulqdq $(0), %xmm6, %xmm5
movdqa %xmm3, %xmm4
pclmulqdq $(0), %xmm8, %xmm3
pxor %xmm6, %xmm6
pclmulqdq $(17), %xmm8, %xmm4
pxor %xmm3, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm6
pslldq $(8), %xmm5
pxor %xmm6, %xmm4
pxor %xmm5, %xmm3
movdqa %xmm3, %xmm6
movdqa %xmm3, %xmm5
movdqa %xmm3, %xmm15
psllq $(63), %xmm6
psllq $(62), %xmm5
psllq $(57), %xmm15
pxor %xmm5, %xmm6
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm6
pxor %xmm5, %xmm3
pxor %xmm6, %xmm4
movdqa %xmm3, %xmm5
psrlq $(5), %xmm5
pxor %xmm3, %xmm5
psrlq $(1), %xmm5
pxor %xmm3, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm3
pxor %xmm4, %xmm3
pxor %xmm0, %xmm3
movdqa %xmm3, (32)(%rsp)
.Lsingle_block_procgas_4:
test %rax, %rax
jz .Lquitgas_4
.p2align 5, 0x90
.Lblk_loopgas_4:
movdqa (%rsp), %xmm0
movdqa %xmm0, %xmm1
paddd INC_1(%rip), %xmm1
movdqa %xmm1, (%rsp)
movdqa (%rcx), %xmm0
mov %rcx, %r10
pshufb SHUF_CONST(%rip), %xmm1
pxor %xmm0, %xmm1
movdqa (16)(%r10), %xmm0
add $(16), %r10
mov %r8d, %r11d
sub $(1), %r11
.p2align 5, 0x90
.Lcipher_loopgas_4:
aesenc %xmm0, %xmm1
movdqa (16)(%r10), %xmm0
add $(16), %r10
dec %r11
jnz .Lcipher_loopgas_4
aesenclast %xmm0, %xmm1
movdqa (16)(%rsp), %xmm0
movdqa %xmm1, (16)(%rsp)
movdqu (%rsi), %xmm1
add $(16), %rsi
pxor %xmm1, %xmm0
movdqu %xmm0, (%rdi)
add $(16), %rdi
pshufb SHUF_CONST(%rip), %xmm0
pxor (32)(%rsp), %xmm0
movdqa (%rbx), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm15
psllq $(63), %xmm2
psllq $(62), %xmm4
psllq $(57), %xmm15
pxor %xmm4, %xmm2
pxor %xmm15, %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
movdqa %xmm0, (32)(%rsp)
sub $(16), %rax
jg .Lblk_loopgas_4
.Lquitgas_4:
movdqa (%rsp), %xmm0
movdqa (16)(%rsp), %xmm1
movdqa (32)(%rsp), %xmm2
mov (152)(%rsp), %rax
mov (160)(%rsp), %rbx
mov (144)(%rsp), %rcx
pshufb SHUF_CONST(%rip), %xmm0
movdqu %xmm0, (%rax)
movdqu %xmm1, (%rbx)
pshufb SHUF_CONST(%rip), %xmm2
movdqu %xmm2, (%rcx)
add $(128), %rsp
vzeroupper
pop %rbx
ret
.p2align 5, 0x90
.globl _e9_AesGcmDec_avx
_e9_AesGcmDec_avx:
push %rbx
sub $(128), %rsp
mov (152)(%rsp), %rax
mov (160)(%rsp), %rbx
mov (144)(%rsp), %rcx
movdqa SHUF_CONST(%rip), %xmm4
movdqu (%rax), %xmm0
movdqu (%rbx), %xmm1
movdqu (%rcx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%rsp)
movdqa %xmm1, (16)(%rsp)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%rsp)
movdqa %xmm1, (48)(%rsp)
movdqa %xmm1, (64)(%rsp)
movdqa %xmm1, (80)(%rsp)
mov (168)(%rsp), %rbx
movdqa (32)(%rbx), %xmm10
pshufd $(78), %xmm10, %xmm9
pxor %xmm10, %xmm9
movdqa %xmm9, (96)(%rsp)
movslq %edx, %rdx
mov %r9, %rcx
mov %rdx, %rax
and $(63), %rax
and $(-64), %rdx
jz .Lsingle_block_procgas_5
.p2align 5, 0x90
.Lblks4_loopgas_5:
movdqa INC_1(%rip), %xmm6
movdqa SHUF_CONST(%rip), %xmm5
movdqa %xmm0, %xmm1
paddd INC_1(%rip), %xmm1
movdqa %xmm1, %xmm2
paddd INC_1(%rip), %xmm2
movdqa %xmm2, %xmm3
paddd INC_1(%rip), %xmm3
movdqa %xmm3, %xmm4
paddd INC_1(%rip), %xmm4
movdqa %xmm4, (%rsp)
movdqa (%rcx), %xmm0
mov %rcx, %r10
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (16)(%r10), %xmm0
add $(16), %r10
mov %r8d, %r11d
sub $(1), %r11
.p2align 5, 0x90
.Lcipher4_loopgas_5:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (16)(%r10), %xmm0
add $(16), %r10
dec %r11
jnz .Lcipher4_loopgas_5
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%rsp), %xmm0
movdqa %xmm4, (16)(%rsp)
movdqu (%rsi), %xmm4
movdqu (16)(%rsi), %xmm5
movdqu (32)(%rsi), %xmm6
movdqu (48)(%rsi), %xmm7
add $(64), %rsi
pxor %xmm4, %xmm0
movdqu %xmm0, (%rdi)
pshufb SHUF_CONST(%rip), %xmm4
pxor (32)(%rsp), %xmm4
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%rdi)
pshufb SHUF_CONST(%rip), %xmm5
pxor (48)(%rsp), %xmm5
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%rdi)
pshufb SHUF_CONST(%rip), %xmm6
pxor (64)(%rsp), %xmm6
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%rdi)
pshufb SHUF_CONST(%rip), %xmm7
pxor (80)(%rsp), %xmm7
add $(64), %rdi
cmp $(64), %rdx
je .Lcombine_hashgas_5
movdqa MASK1(%rip), %xmm14
pshufd $(78), %xmm4, %xmm2
movdqa %xmm4, %xmm1
pxor %xmm4, %xmm2
pclmulqdq $(0), %xmm10, %xmm4
pshufd $(78), %xmm5, %xmm13
movdqa %xmm5, %xmm12
pxor %xmm5, %xmm13
pclmulqdq $(17), %xmm10, %xmm1
pclmulqdq $(0), %xmm9, %xmm2
pxor %xmm4, %xmm2
pxor %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm0
movdqa %xmm0, %xmm2
pand MASK2(%rip), %xmm0
pand %xmm14, %xmm2
pxor %xmm0, %xmm4
pxor %xmm2, %xmm1
movdqa %xmm4, %xmm0
psllq $(1), %xmm4
pclmulqdq $(0), %xmm10, %xmm5
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
pshufd $(78), %xmm4, %xmm2
movdqa %xmm2, %xmm4
pclmulqdq $(17), %xmm10, %xmm12
pand %xmm14, %xmm2
pand MASK2(%rip), %xmm4
pxor %xmm0, %xmm4
pxor %xmm2, %xmm1
movdqa %xmm4, %xmm2
psrlq $(5), %xmm4
pclmulqdq $(0), %xmm9, %xmm13
pxor %xmm2, %xmm4
psrlq $(1), %xmm4
pxor %xmm2, %xmm4
psrlq $(1), %xmm4
pxor %xmm2, %xmm4
pxor %xmm1, %xmm4
pxor %xmm5, %xmm13
pxor %xmm12, %xmm13
pshufd $(78), %xmm13, %xmm11
movdqa %xmm11, %xmm13
pand MASK2(%rip), %xmm11
pand %xmm14, %xmm13
pxor %xmm11, %xmm5
pxor %xmm13, %xmm12
movdqa %xmm5, %xmm11
movdqa %xmm5, %xmm13
movdqa %xmm5, %xmm15
psllq $(63), %xmm11
psllq $(62), %xmm13
psllq $(57), %xmm15
pxor %xmm13, %xmm11
pxor %xmm15, %xmm11
movdqa %xmm11, %xmm13
pslldq $(8), %xmm13
psrldq $(8), %xmm11
pxor %xmm13, %xmm5
pxor %xmm11, %xmm12
movdqa %xmm5, %xmm13
psrlq $(5), %xmm13
pxor %xmm5, %xmm13
psrlq $(1), %xmm13
pxor %xmm5, %xmm13
psrlq $(1), %xmm13
pxor %xmm13, %xmm5
pxor %xmm12, %xmm5
pshufd $(78), %xmm6, %xmm2
movdqa %xmm6, %xmm1
pxor %xmm6, %xmm2
pclmulqdq $(0), %xmm10, %xmm6
pshufd $(78), %xmm7, %xmm13
movdqa %xmm7, %xmm12
pxor %xmm7, %xmm13
pclmulqdq $(17), %xmm10, %xmm1
pclmulqdq $(0), %xmm9, %xmm2
pxor %xmm6, %xmm2
pxor %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm0
movdqa %xmm0, %xmm2
pand MASK2(%rip), %xmm0
pand %xmm14, %xmm2
pxor %xmm0, %xmm6
pxor %xmm2, %xmm1
movdqa %xmm6, %xmm0
psllq $(1), %xmm6
pclmulqdq $(0), %xmm10, %xmm7
pxor %xmm0, %xmm6
psllq $(5), %xmm6
pxor %xmm0, %xmm6
psllq $(57), %xmm6
pshufd $(78), %xmm6, %xmm2
movdqa %xmm2, %xmm6
pclmulqdq $(17), %xmm10, %xmm12
pand %xmm14, %xmm2
pand MASK2(%rip), %xmm6
pxor %xmm0, %xmm6
pxor %xmm2, %xmm1
movdqa %xmm6, %xmm2
psrlq $(5), %xmm6
pclmulqdq $(0), %xmm9, %xmm13
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
pxor %xmm1, %xmm6
pxor %xmm7, %xmm13
pxor %xmm12, %xmm13
pshufd $(78), %xmm13, %xmm11
movdqa %xmm11, %xmm13
pand MASK2(%rip), %xmm11
pand %xmm14, %xmm13
pxor %xmm11, %xmm7
pxor %xmm13, %xmm12
movdqa %xmm7, %xmm11
movdqa %xmm7, %xmm13
movdqa %xmm7, %xmm15
psllq $(63), %xmm11
psllq $(62), %xmm13
psllq $(57), %xmm15
pxor %xmm13, %xmm11
pxor %xmm15, %xmm11
movdqa %xmm11, %xmm13
pslldq $(8), %xmm13
psrldq $(8), %xmm11
pxor %xmm13, %xmm7
pxor %xmm11, %xmm12
movdqa %xmm7, %xmm13
psrlq $(5), %xmm13
pxor %xmm7, %xmm13
psrlq $(1), %xmm13
pxor %xmm7, %xmm13
psrlq $(1), %xmm13
pxor %xmm13, %xmm7
pxor %xmm12, %xmm7
movdqa %xmm4, (32)(%rsp)
movdqa %xmm5, (48)(%rsp)
movdqa %xmm6, (64)(%rsp)
movdqa %xmm7, (80)(%rsp)
sub $(64), %rdx
movdqa (%rsp), %xmm0
cmp $(64), %rdx
jge .Lblks4_loopgas_5
.Lcombine_hashgas_5:
movdqa (%rbx), %xmm8
movdqa (16)(%rbx), %xmm9
pshufd $(78), %xmm4, %xmm2
pshufd $(78), %xmm10, %xmm0
pxor %xmm4, %xmm2
pxor %xmm10, %xmm0
pclmulqdq $(0), %xmm0, %xmm2
movdqa %xmm4, %xmm1
pclmulqdq $(0), %xmm10, %xmm4
pxor %xmm0, %xmm0
pclmulqdq $(17), %xmm10, %xmm1
pxor %xmm4, %xmm2
pxor %xmm1, %xmm2
palignr $(8), %xmm2, %xmm0
pslldq $(8), %xmm2
pxor %xmm0, %xmm1
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm0
movdqa %xmm4, %xmm2
movdqa %xmm4, %xmm15
psllq $(63), %xmm0
psllq $(62), %xmm2
psllq $(57), %xmm15
pxor %xmm2, %xmm0
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm2
pslldq $(8), %xmm2
psrldq $(8), %xmm0
pxor %xmm2, %xmm4
pxor %xmm0, %xmm1
movdqa %xmm4, %xmm2
psrlq $(5), %xmm2
pxor %xmm4, %xmm2
psrlq $(1), %xmm2
pxor %xmm4, %xmm2
psrlq $(1), %xmm2
pxor %xmm2, %xmm4
pxor %xmm1, %xmm4
pshufd $(78), %xmm5, %xmm2
pshufd $(78), %xmm9, %xmm0
pxor %xmm5, %xmm2
pxor %xmm9, %xmm0
pclmulqdq $(0), %xmm0, %xmm2
movdqa %xmm5, %xmm1
pclmulqdq $(0), %xmm9, %xmm5
pxor %xmm0, %xmm0
pclmulqdq $(17), %xmm9, %xmm1
pxor %xmm5, %xmm2
pxor %xmm1, %xmm2
palignr $(8), %xmm2, %xmm0
pslldq $(8), %xmm2
pxor %xmm0, %xmm1
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm0
movdqa %xmm5, %xmm2
movdqa %xmm5, %xmm15
psllq $(63), %xmm0
psllq $(62), %xmm2
psllq $(57), %xmm15
pxor %xmm2, %xmm0
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm2
pslldq $(8), %xmm2
psrldq $(8), %xmm0
pxor %xmm2, %xmm5
pxor %xmm0, %xmm1
movdqa %xmm5, %xmm2
psrlq $(5), %xmm2
pxor %xmm5, %xmm2
psrlq $(1), %xmm2
pxor %xmm5, %xmm2
psrlq $(1), %xmm2
pxor %xmm2, %xmm5
pxor %xmm1, %xmm5
pshufd $(78), %xmm6, %xmm2
pshufd $(78), %xmm8, %xmm0
pxor %xmm6, %xmm2
pxor %xmm8, %xmm0
pclmulqdq $(0), %xmm0, %xmm2
movdqa %xmm6, %xmm1
pclmulqdq $(0), %xmm8, %xmm6
pxor %xmm0, %xmm0
pclmulqdq $(17), %xmm8, %xmm1
pxor %xmm6, %xmm2
pxor %xmm1, %xmm2
palignr $(8), %xmm2, %xmm0
pslldq $(8), %xmm2
pxor %xmm0, %xmm1
pxor %xmm2, %xmm6
movdqa %xmm6, %xmm0
movdqa %xmm6, %xmm2
movdqa %xmm6, %xmm15
psllq $(63), %xmm0
psllq $(62), %xmm2
psllq $(57), %xmm15
pxor %xmm2, %xmm0
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm2
pslldq $(8), %xmm2
psrldq $(8), %xmm0
pxor %xmm2, %xmm6
pxor %xmm0, %xmm1
movdqa %xmm6, %xmm2
psrlq $(5), %xmm2
pxor %xmm6, %xmm2
psrlq $(1), %xmm2
pxor %xmm6, %xmm2
psrlq $(1), %xmm2
pxor %xmm2, %xmm6
pxor %xmm1, %xmm6
pxor %xmm5, %xmm7
pxor %xmm6, %xmm7
pshufd $(78), %xmm7, %xmm2
pshufd $(78), %xmm8, %xmm0
pxor %xmm7, %xmm2
pxor %xmm8, %xmm0
pclmulqdq $(0), %xmm0, %xmm2
movdqa %xmm7, %xmm1
pclmulqdq $(0), %xmm8, %xmm7
pxor %xmm0, %xmm0
pclmulqdq $(17), %xmm8, %xmm1
pxor %xmm7, %xmm2
pxor %xmm1, %xmm2
palignr $(8), %xmm2, %xmm0
pslldq $(8), %xmm2
pxor %xmm0, %xmm1
pxor %xmm2, %xmm7
movdqa %xmm7, %xmm0
movdqa %xmm7, %xmm2
movdqa %xmm7, %xmm15
psllq $(63), %xmm0
psllq $(62), %xmm2
psllq $(57), %xmm15
pxor %xmm2, %xmm0
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm2
pslldq $(8), %xmm2
psrldq $(8), %xmm0
pxor %xmm2, %xmm7
pxor %xmm0, %xmm1
movdqa %xmm7, %xmm2
psrlq $(5), %xmm2
pxor %xmm7, %xmm2
psrlq $(1), %xmm2
pxor %xmm7, %xmm2
psrlq $(1), %xmm2
pxor %xmm2, %xmm7
pxor %xmm1, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, (32)(%rsp)
.Lsingle_block_procgas_5:
test %rax, %rax
jz .Lquitgas_5
.p2align 5, 0x90
.Lblk_loopgas_5:
movdqa (%rsp), %xmm0
movdqa %xmm0, %xmm1
paddd INC_1(%rip), %xmm1
movdqa %xmm1, (%rsp)
movdqa (%rcx), %xmm0
mov %rcx, %r10
pshufb SHUF_CONST(%rip), %xmm1
pxor %xmm0, %xmm1
movdqa (16)(%r10), %xmm0
add $(16), %r10
mov %r8d, %r11d
sub $(1), %r11
.p2align 5, 0x90
.Lcipher_loopgas_5:
aesenc %xmm0, %xmm1
movdqa (16)(%r10), %xmm0
add $(16), %r10
dec %r11
jnz .Lcipher_loopgas_5
aesenclast %xmm0, %xmm1
movdqa (16)(%rsp), %xmm0
movdqa %xmm1, (16)(%rsp)
movdqu (%rsi), %xmm1
add $(16), %rsi
pxor %xmm1, %xmm0
movdqu %xmm0, (%rdi)
add $(16), %rdi
pshufb SHUF_CONST(%rip), %xmm1
pxor (32)(%rsp), %xmm1
movdqa (%rbx), %xmm0
pshufd $(78), %xmm1, %xmm4
pshufd $(78), %xmm0, %xmm2
pxor %xmm1, %xmm4
pxor %xmm0, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm1, %xmm3
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm0, %xmm3
pxor %xmm1, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm1, %xmm4
movdqa %xmm1, %xmm15
psllq $(63), %xmm2
psllq $(62), %xmm4
psllq $(57), %xmm15
pxor %xmm4, %xmm2
pxor %xmm15, %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm1
pxor %xmm2, %xmm3
movdqa %xmm1, %xmm4
psrlq $(5), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm1
pxor %xmm3, %xmm1
movdqa %xmm1, (32)(%rsp)
sub $(16), %rax
jg .Lblk_loopgas_5
.Lquitgas_5:
movdqa (%rsp), %xmm0
movdqa (16)(%rsp), %xmm1
movdqa (32)(%rsp), %xmm2
mov (152)(%rsp), %rax
mov (160)(%rsp), %rbx
mov (144)(%rsp), %rcx
pshufb SHUF_CONST(%rip), %xmm0
movdqu %xmm0, (%rax)
movdqu %xmm1, (%rbx)
pshufb SHUF_CONST(%rip), %xmm2
movdqu %xmm2, (%rcx)
add $(128), %rsp
vzeroupper
pop %rbx
ret
",16253,True,4899.957049251678,median
"// Just to clarify comments, I'm describing the palette pattern
// in terms of the palettes index. Or it'll be copied from the
// PaletteKnife shit
//
// W == White
// B == Black
// RB == Rainbow, uses global hue position
// X == Input to the function
//////////////////////////////////////////////////////////////////////////////////
// These template need to be updated before each fill call. This is because //
// they are either dependend on an input or they rely on some global variable //
// that is changed in the animations. //
//////////////////////////////////////////////////////////////////////////////////
// RB|B|B|B repeating
void update_RainbowBlack_p() {
// Instead of blacking out, fill backgroud with rainbow, then
// fill every thing with black except
fill_palette(gPalette, 16, gHue, 16, RainbowColors_p, gBrightness, gBlending);
for (uint8_t i = 0 ; i < 16; i++) {
if ( i % 4 == 0) {
continue;
}
gPalette[i] = CRGB::Black;
}
}
void update_Rainbow_p() {
fill_palette(gPalette, 16, gHue, 16, RainbowColors_p, gBrightness, gBlending);
}
// W|RB|RB|RB repeating
void update_WhiteRainbow_p() {
fill_palette(gPalette, 16, gHue, 16, RainbowColors_p, gBrightness, gBlending);
gPalette[0] = CHSV(255, 0, gBrightness);
gPalette[4] = CHSV(255, 0, gBrightness);
gPalette[8] = CHSV(255, 0, gBrightness);
gPalette[12] = CHSV(255, 0, gBrightness);
}
// Hue adjustable palettes!!!
const uint8_t val_offset = 100;
// X_LEAD|X_BACK|X_BACK|X_BACK repeating
void update_WhiteCol_p() {
fill_solid( gPalette, 16, CHSV(gHue, 255, gBrightness));
gPalette[0] = CHSV(255, 0, gBrightness);
gPalette[4] = CHSV(255, 0, gBrightness);
gPalette[8] = CHSV(255, 0, gBrightness);
gPalette[12] = CHSV(255, 0, gBrightness);
}
void update_TwoCol_p() {
for (uint8_t i = 0; i < 16; i++) {
if (i % 4 == 0) {
gPalette[i] = CHSV(gHue, 255, gBrightness + val_offset);
}
else {
gPalette[i] = CHSV((gHue + 128) % 255, 255, gBrightness + val_offset);
}
}
}
void update_FourCol_p() {
for (uint8_t i = 0; i < 16; i++) {
if (i % 4 == 0) {
gPalette[i] = CHSV(gHue, 255, gBrightness);
}
else if (i % 4 == 1) {
gPalette[i] = CHSV((gHue + 64) % 255, 255, gBrightness + val_offset);
}
else if (i % 4 == 2) {
gPalette[i] = CHSV((gHue + 128) % 255, 255, gBrightness + val_offset);
}
else if (i % 4 == 3) {
gPalette[i] = CHSV((gHue + 192) % 255, 255, gBrightness + val_offset);
}
}
}
// One color at the front and nothing else
void update_ColLead_p() {
for (uint8_t i = 0; i < 16; i++) {
if (i % 4 == 0) {
gPalette[i] = CHSV(gHue, 255, gBrightness + val_offset);
}
else {
gPalette[i] = CRGB::Black;
}
}
}
void update_WhiteBlack_p() {
for (uint8_t i = 0; i < 16; i++) {
if (i % 4 == 0) {
gPalette[i] = CHSV(255, 0, gBrightness);
}
else {
gPalette[i] = CRGB::Black;
}
}
}
//////////////////////////////////////////////////////////////////////////////////
// Static templates. These are templates that do not need to be update //
// since they are not modular and don't have any dependence on global variables //
//////////////////////////////////////////////////////////////////////////////////
// Gradient palette ""chroma_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/fractint/base/tn/chroma.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 2840 bytes of program space.
DEFINE_GRADIENT_PALETTE( chroma_gp ) {
0, 4, 6, 5,
0, 4, 6, 5,
0, 7, 6, 8,
1, 7, 6, 8,
1, 9, 6, 10,
2, 9, 6, 10,
2, 12, 6, 14,
2, 12, 6, 14,
2, 16, 6, 17,
3, 16, 6, 17,
3, 20, 6, 22,
4, 20, 6, 22,
4, 24, 6, 27,
5, 24, 6, 27,
5, 30, 6, 32,
5, 30, 6, 32,
5, 35, 6, 38,
6, 35, 6, 38,
6, 42, 6, 45,
7, 42, 6, 45,
7, 49, 6, 52,
7, 49, 6, 52,
7, 57, 6, 61,
8, 57, 6, 61,
8, 66, 6, 69,
9, 66, 6, 69,
9, 75, 6, 79,
10, 75, 6, 79,
10, 86, 6, 89,
10, 86, 6, 89,
10, 97, 6, 100,
11, 97, 6, 100,
11, 109, 6, 112,
12, 109, 6, 112,
12, 121, 6, 125,
12, 121, 6, 125,
12, 135, 37, 182, 9, 3,
237, 182, 9, 3,
237, 182, 6, 3,
238, 182, 6, 3,
238, 165, 6, 3,
239, 165, 6, 3,
239, 150, 6, 3,
239, 150, 6, 3,
239, 135, 6, 3,
240, 135, 6, 3,
240, 121, 6, 3,
241, 121, 6, 3,
241, 109, 6, 3,
242, 109, 6, 3,
242, 97, 6, 3,
242, 97, 6, 3,
242, 86, 6, 3,
243, 86, 6, 3,
243, 75, 6, 3,
244, 75, 6, 3,
244, 66, 6, 3,
244, 66, 6, 3,
244, 57, 6, 3,
245, 57, 6, 3,
245, 49, 6, 3,
246, 49, 6, 3,
246, 42, 6, 3,
247, 42, 6, 3,
247, 35, 6, 3,
247, 35, 6, 3,
247, 30, 6, 3,
248, 30, 6, 3,
248, 24, 6, 3,
249, 24, 6, 3,
249, 20, 6, 3,
249, 20, 6, 3,
249, 16, 6, 3,
250, 16, 6, 3,
250, 12, 6, 3,
251, 12, 6, 3,
251, 9, 6, 3,
252, 9, 6, 3,
252, 7, 6, 3,
252, 7, 6, 3,
252, 4, 6, 3,
253, 4, 6, 3,
253, 3, 6, 3,
254, 3, 6, 3,
254, 2, 6, 3,
255, 2, 6, 3
};
// Gradient palette ""sprinkles_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/alpen/tn/sprinkles.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( sprinkles_gp ) {
0, 67, 1, 10,
109, 67, 1, 10,
109, 194, 3, 8,
145, 194, 3, 8,
145, 229, 39, 2,
158, 229, 39, 2,
158, 217, 119, 8,
170, 217, 119, 8,
170, 55, 217, 242,
255, 55, 217, 242
};
// Gradient palette ""GMT_no_green_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/gmt/tn/GMT_no_green.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 128 bytes of program space.
DEFINE_GRADIENT_PALETTE( GMT_no_green_gp ) {
0, 1, 29, 255,
15, 1, 29, 255,
15, 1, 90, 255,
31, 1, 90, 255,
31, 1, 135, 255,
47, 1, 135, 255,
47, 0, 161, 255,
63, 0, 161, 255,
63, 2, 255, 255,
79, 2, 255, 255,
79, 14, 255, 255,
95, 14, 255, 255,
95, 41, 255, 255,
111, 41, 255, 255,
111, 88, 255, 255,
127, 88, 255, 255,
127, 255, 255, 15,
143, 255, 255, 15,
143, 255, 223, 0,
159, 255, 223, 0,
159, 255, 135, 0,
175, 255, 135, 0,
175, 255, 101, 0,
191, 255, 101, 0,
191, 255, 66, 0,
207, 255, 66, 0,
207, 255, 41, 0,
223, 255, 41, 0,
223, 255, 18, 0,
239, 255, 18, 0,
239, 255, 0, 0,
255, 255, 0, 0
};
// Gradient palette ""GMT_sealand_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/gmt/tn/GMT_sealand.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 80 bytes of program space.
DEFINE_GRADIENT_PALETTE( GMT_sealand_gp ) {
0, 53, 33, 255,
14, 23, 33, 255,
28, 23, 68, 255,
42, 23, 115, 255,
56, 23, 178, 255,
70, 23, 255, 255,
84, 23, 255, 170,
99, 23, 255, 103,
113, 23, 255, 56,
127, 23, 255, 25,
141, 53, 255, 25,
155, 100, 255, 25,
170, 167, 255, 25,
170, 255, 255, 87,
184, 255, 193, 87,
198, 255, 141, 87,
212, 255, 99, 87,
226, 255, 115, 135,
240, 255, 135, 182,
255, 255, 156, 223
};
// Gradient palette ""GMT_cool_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/gmt/tn/GMT_cool.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 8 bytes of program space.
DEFINE_GRADIENT_PALETTE( GMT_cool_gp ) {
0, 0, 255, 255,
255, 255, 0, 255
};
// Gradient palette ""aspectcolr_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/grass/tn/aspectcolr.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 24 bytes of program space.
DEFINE_GRADIENT_PALETTE( aspectcolr_gp ) {
0, 255, 255, 255,
0, 255, 255, 0,
63, 0, 255, 0,
127, 0, 255, 255,
191, 255, 0, 0,
255, 255, 255, 0
};
// Gradient palette ""haxby_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/grass/tn/haxby.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 44 bytes of program space.
DEFINE_GRADIENT_PALETTE( haxby_gp ) {
0, 1, 9, 99,
25, 2, 55, 245,
51, 3, 133, 255,
76, 26, 213, 255,
102, 51, 215, 98,
127, 144, 255, 82,
153, 217, 215, 39,
178, 255, 131, 17,
204, 255, 92, 9,
229, 255, 127, 50,
255, 255, 255, 255
};
// Gradient palette ""differences_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/grass/tn/differences.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 12 bytes of program space.
DEFINE_GRADIENT_PALETTE( differences_gp ) {
0, 0, 0, 255,
127, 255, 255, 255,
255, 255, 0, 0
};
// Gradient palette ""cool_warm_d05_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/km/tn/cool-warm-d05.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( cool_warm_d05_gp ) {
0, 8, 38, 180,
51, 8, 38, 180,
51, 36, 111, 230,
102, 36, 111, 230,
102, 179, 189, 182,
153, 179, 189, 182,
153, 255, 37, 27,
204, 255, 37, 27,
204, 232, 2, 6,
255, 232, 2, 6
};
// Gradient palette ""purple_orange_d07_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/km/tn/purple-orange-d07.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 56 bytes of program space.
DEFINE_GRADIENT_PALETTE( purple_orange_d07_gp ) {
0, 53, 27, 91,
36, 53, 27, 91,
36, 121, 55, 111,
72, 121, 55, 111,
72, 179, 107, 137,
109, 179, 107, 137,
109, 179, 189, 182,
145, 179, 189, 182,
145, 234, 152, 59,
182, 234, 152, 59,
182, 227, 92, 11,
218, 227, 92, 11,
218, 165, 40, 1,
255, 165, 40, 1
};
// Gradient palette ""Lucy_in_the_Sky_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/vredeling/tn/Lucy_in_the_Sky.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( Lucy_in_the_Sky_gp ) {
0, 175, 1, 44,
51, 175, 1, 44,
51, 194, 14, 35,
102, 194, 14, 35,
102, 213, 40, 27,
153, 213, 40, 27,
153, 234, 80, 21,
204, 234, 80, 21,
204, 255, 136, 15,
255, 255, 136, 15
};
// Gradient palette ""Alive_And_Kicking_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/rphnick/tn/Alive_And_Kicking.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( Alive_And_Kicking_gp ) {
0, 192, 50, 207,
51, 192, 50, 207,
51, 87, 50, 207,
102, 87, 50, 207,
102, 37, 73, 207,
153, 37, 73, 207,
153, 37, 127, 207,
204, 37, 127, 207,
204, 37, 213, 140,
255, 37, 213, 140
};
// Gradient palette ""firestrm_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/fractint/base/tn/firestrm.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 2040 bytes of program space.
DEFINE_GRADIENT_PALETTE( firestrm_gp ) {
0, 57, 1, 194,
0, 57, 1, 194,
0, 60, 1, 190,
1, 60, 1, 190,
1, 64, 1, 186,
3, 64, 1, 186,
3, 67, 1, 182,
4, 67, 1, 182,
4, 71, 1, 178,
4, 71, 1, 178,
4, 74, 1, 172,
5, 74, 1, 172,
5, 78, 1, 168,
7, 78, 1, 168,
7, 82, 1, 164,
8, 82, 1, 164,
8, 86, 1, 160,
9, 86, 1, 160,
9, 90, 1, 155,
9, 90, 1, 155,
9, 94, 1, 151,
10, 94, 1, 151,
10, 98, 1, 145,
12, 98, 1, 145,
12, 103, 1, 142,
13, 103, 1, 142,
13, 107, 0, 137,
13, 107, 0, 137,
13, 112, 0, 133,
14, 112, 0, 133,
14, 117, 0, 128,
15, 117, 0, 128,
15, 120, 0, 123,
17, 120, 0, 123,
17, 125, 0, 120,
18, 125, 0, 120,
18, 30, 8, 10, 255,
231, 8, 10, 255,
231, 9, 9, 255,
231, 9, 9, 255,
231, 9, 8, 255,
232, 9, 8, 255,
232, 10, 7, 252,
233, 10, 7, 252,
233, 12, 6, 252,
235, 12, 6, 252,
235, 13, 6, 250,
236, 13, 6, 250,
236, 14, 5, 250,
236, 14, 5, 250,
236, 16, 4, 247,
237, 16, 4, 247,
237, 17, 4, 247,
239, 17, 4, 247,
239, 19, 3, 245,
240, 19, 3, 245,
240, 20, 3, 242,
241, 20, 3, 242,
241, 22, 2, 240,
241, 22, 2, 240,
241, 24, 2, 237,
242, 24, 2, 237,
242, 26, 2, 235,
244, 26, 2, 235,
244, 27, 1, 233,
245, 27, 1, 233,
245, 30, 1, 230,
245, 30, 1, 230,
245, 32, 1, 226,
246, 32, 1, 226,
246, 35, 1, 223,
247, 35, 1, 223,
247, 37, 1, 221,
249, 37, 1, 221,
249, 39, 1, 216,
250, 39, 1, 216,
250, 42, 1, 214,
250, 42, 1, 214,
250, 45, 1, 210,
251, 45, 1, 210,
251, 48, 1, 205,
253, 48, 1, 205,
253, 51, 1, 201,
254, 51, 1, 201,
254, 54, 1, 197,
255, 54, 1, 197
};
// Gradient palette ""royal_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/fractint/base/tn/royal.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 1896 bytes of program space.
DEFINE_GRADIENT_PALETTE( royal_gp ) {
0, 5, 0, 14,
0, 5, 0, 14,
1, 5, 0, 14,
1, 5, 0, 15,
3, 5, 0, 15,
3, 7, 0, 15,
4, 7, 0, 15,
4, 7, 0, 15,
4, 7, 0, 17,
5, 7, 0, 17,
7, 7, 0, 17,
7, 8, 0, 17,
8, 8, 0, 17,
8, 8, 0, 19,
9, 8, 0, 19,
9, 8, 0, 19,
10, 8, 0, 19,
10, 9, 0, 22,
12, 9, 0, 22,
13, 9, 0, 22,
13, 9, 0, 22,
13, 9, 0, 24,
14, 9, 0, 24,
14, 10, 0, 24,
15, 10, 0, 24,
17, 10, 0, 24,
17, 10, 0, 27,
18, 10, 0, 27,
18, 10, 0, 27,
19, 10, 0, 27,
19, 12, 0, 27,
21, 12, 0, 27,
21, 12, 0, 29,
22, 12, 0, 29,
23, 12, 0, 29,
23, 12, 0, 29,
23, 14, 0, 28, 46, 29, 3,
228, 46, 27, 3,
230, 46, 27, 3,
230, 42, 24, 4,
231, 42, 24, 4,
231, 39, 22, 4,
231, 39, 22, 4,
231, 35, 19, 4,
232, 35, 19, 4,
232, 32, 17, 5,
233, 32, 17, 5,
233, 32, 15, 5,
235, 32, 15, 5,
235, 30, 13, 5,
236, 30, 13, 5,
236, 27, 12, 6,
236, 27, 12, 6,
236, 24, 10, 6,
237, 24, 10, 6,
237, 24, 9, 6,
239, 24, 9, 6,
239, 22, 7, 8,
240, 22, 7, 8,
240, 20, 6, 8,
241, 20, 6, 8,
241, 18, 5, 8,
241, 18, 5, 8,
241, 16, 4, 9,
242, 16, 4, 9,
242, 16, 3, 9,
244, 16, 3, 9,
244, 14, 2, 9,
245, 14, 2, 9,
245, 12, 1, 10,
245, 12, 1, 10,
245, 10, 1, 10,
246, 10, 1, 10,
246, 10, 1, 10,
247, 10, 1, 10,
247, 9, 1, 12,
249, 9, 1, 12,
249, 8, 1, 12,
250, 8, 1, 12,
250, 7, 1, 12,
250, 7, 1, 12,
250, 5, 0, 14,
251, 5, 0, 14,
253, 5, 0, 14,
254, 5, 0, 14,
255, 5, 0, 14
};
// Gradient palette ""moldy_bread_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/phill/tn/moldy_bread.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( moldy_bread_gp ) {
0, 32, 105, 51,
51, 32, 105, 51,
51, 34, 139, 60,
102, 34, 139, 60,
102, 110, 182, 19,
153, 110, 182, 19,
153, 184, 203, 22,
204, 184, 203, 22,
204, 239, 248, 72,
255, 239, 248, 72
};
// Gradient palette ""Floating_Away_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/lightningmccarl/tn/Floating_Away.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( Floating_Away_gp ) {
0, 82, 205, 223,
51, 82, 205, 223,
51, 39, 144, 155,
102, 39, 144, 155,
102, 46, 112, 112,
153, 46, 112, 112,
153, 39, 70, 62,
204, 39, 70, 62,
204, 22, 33, 25,
255, 22, 33, 25
};
// Gradient palette ""3_girls_reclining_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/evad/tn/3_girls_reclining.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( three_girls_reclining_gp ) {
0, 6, 45, 16,
51, 6, 45, 16,
51, 135, 201, 108,
102, 135, 201, 108,
102, 227, 221, 151,
153, 227, 221, 151,
153, 83, 182, 186,
204, 83, 182, 186,
204, 159, 127, 178,
255, 159, 127, 178
};
// Gradient palette ""iCreate_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/electroluv/tn/iCreate.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( iCreate_gp ) {
0, 210, 80, 22,
20, 210, 80, 22,
20, 255, 23, 17,
58, 255, 23, 17,
58, 167, 1, 21,
107, 167, 1, 21,
107, 46, 1, 8,
163, 46, 1, 8,
163, 12, 1, 4,
255, 12, 1, 4
};
// Gradient palette ""Opaque_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/drumma/tn/Opaque.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( Opaque_gp ) {
0, 192, 203, 112,
51, 192, 203, 112,
51, 132, 169, 112,
102, 132, 169, 112,
102, 27, 99, 83,
153, 27, 99, 83,
153, 46, 36, 28,
204, 46, 36, 28,
204, 71, 7, 19,
255, 71, 7, 19
};
// Gradient palette ""500_LOVERS_ThankYou_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/adgrapho/tn/500_LOVERS_ThankYou.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( FiveHundo_LOVERS_ThankYou_gp ) {
0, 222, 10, 7,
51, 222, 10, 7,
51, 255, 71, 21,
102, 255, 71, 21,
102, 242, 173, 47,
153, 242, 173, 47,
153, 184, 233, 91,
204, 184, 233, 91,
204, 39, 182, 137,
255, 39, 182, 137
};
// Gradient palette ""mellon_ball_surprise_gp"", originally from
// http://soliton.vm.bytemark.co.uk/pub/cpt-city/colo/Skyblue2u/tn/mellon_ball_surprise.png.index.html
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 40 bytes of program space.
DEFINE_GRADIENT_PALETTE( mellon_ball_surprise_gp ) {
0, 152, 227, 85,
51, 152, 227, 85,
51, 215, 244, 106,
102, 215, 244, 106,
102, 255, 142, 56,
153, 255, 142, 56,
153, 255, 90, 45,
204, 255, 90, 45,
204, 229, 36, 62,
255, 229, 36, 62
};
// This has to be hand counted and updated whenever we add more palettes. There are also some predefined palettes
// that need to get accounted for :(
const uint8_t numPalettes = 28;
// This handles the switching of palettes based on the global palette counter. Need to add palettes to this function
// whenever they are added up above. Declare it down here so we can get away with not having to use the Gradient Palette
// Pointer array.
void updateGPalette() {
switch (gPaletteCounter) {
case 0:
update_RainbowBlack_p();
break;
case 1:
update_WhiteRainbow_p();
break;
case 2:
update_Rainbow_p();
break;
case 3:
update_WhiteCol_p();
break;
case 4:
update_TwoCol_p();
break;
case 5:
update_ColLead_p();
break;
case 6:
update_WhiteBlack_p();
break;
// Have to use gGradientPalettes array because the gradient defines
// are below us. Maybe we should move this to the Palettes tab so we don't
// have to use this array shit.
case 7:
gPalette = chroma_gp;
break;
case 8:
gPalette = sprinkles_gp;
break;
case 9:
gPalette = GMT_no_green_gp;
break;
case 10:
gPalette = GMT_sealand_gp;
break;
case 11:
gPalette = GMT_cool_gp;
break;
case 12:
gPalette = aspectcolr_gp;
break;
case 13:
gPalette = haxby_gp;
break;
case 14:
gPalette = differences_gp;
break;
case 15:
gPalette = cool_warm_d05_gp;
break;
case 16:
gPalette = purple_orange_d07_gp;
break;
case 17:
gPalette = Lucy_in_the_Sky_gp;
break;
case 18:
gPalette = Alive_And_Kicking_gp;
break;
case 19:
gPalette = firestrm_gp;
break;
case 20:
gPalette = royal_gp;
break;
case 21:
gPalette = moldy_bread_gp;
break;
case 22:
gPalette = Floating_Away_gp;
break;
case 23:
gPalette = three_girls_reclining_gp;
break;
case 24:
gPalette = iCreate_gp;
break;
case 25:
gPalette = Opaque_gp;
break;
case 26:
gPalette = FiveHundo_LOVERS_ThankYou_gp;
break;
case 27:
gPalette = mellon_ball_surprise_gp;
break;
}
}
",12291,True,3070.214343593613,median
"/* AR2 - Stepper motor robot control software Ver 2.1.5
Copyright (c) 2017, Chris Annin
All rights reserved.
You are free to share, copy and redistribute in any medium
or format. You are free to remix, transform and build upon
this material.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistribution of this software in source or binary forms shall be free
of all charges or fees to the recipient of this software.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
you must give appropriate credit and indicate if changes were made. You may do
so in any reasonable manner, but not in any way that suggests the
licensor endorses you or your use.
Selling AR2 software, robots, robot parts, or any versions of robots or software based on this
work is strictly prohibited.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL CHRIS ANNIN BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
chris.annin@gmail.com
Log:
Ver 2.1.1 - new timing algorithm
Ver 2.1.2 - fix calibration timing
Ver 2.1.3 - base speed to 200 increase step delay to 10
Ver 2.1.4 - added individual joint calibration
Ver 2.1.5 - fixed axis 4 & 6 rotations
*/
// SPEED // millisecond multiplier // raise value to slow robot speeds // DEFAULT = 200
const int SpeedMult = 200;
/*
MOTOR DIRECTION - motor directions can be changed on the caibration page in the software but can also
be changed here: example using DM542T driver(CW) set to 1 - if using ST6600 or DM320T driver(CCW) set to 0
DEFAULT = 111011 */
const int J1rotdir = 1;
const int J2rotdir = 1;
const int J3rotdir = 1;
const int J4rotdir = 0;
const int J5rotdir = 1;
const int J6rotdir = 1;
const int TRACKrotdir = 0;
#include
Servo servo0;
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
Servo servo6;
Servo servo7;
String inData;
String function;
const int J1stepPin = 2;
const int J1dirPin = 3;
const int J2stepPin = 4;
const int J2dirPin = 5;
const int J3stepPin = 6;
const int J3dirPin = 7;
const int J4stepPin = 8;
const int J4dirPin = 9;
const int J5stepPin = 10;
const int J5dirPin = 11;
const int J6stepPin = 12;
const int J6dirPin = 13;
const int TRstepPin = 20;
const int TRdirPin = 21;
const int J1calPin = 14;
const int J2calPin = 15;
const int J3calPin = 16;
const int J4calPin = 17;
const int J5calPin = 18;
const int J6calPin = 19;
const int Input22 = 22;
const int Input23 = 23;
const int Input24 = 24;
const int Input25 = 25;
const int Input26 = 26;
const int Input27 = 27;
const int Input28 = 28;
const int Input29 = 29;
const int Input30 = 30;
const int Input31 = 31;
const int Input32 = 32;
const int Input33 = 33;
const int Input34 = 34;
const int Input35 = 35;
const int Input36 = 36;
const int Input37 = 37;
const int Output38 = 38;
const int Output39 = 39;
const int Output40 = 40;
const int Output41 = 41;
const int Output42 = 42;
const int Output43 = 43;
const int Output44 = 44;
const int Output45 = 45;
const int Output46 = 46;
const int Output47 = 47;
const int Output48 = 48;
const int Output49 = 49;
const int Output50 = 50;
const int Output51 = 51;
const int Output52 = 52;
const int Output53 = 53;
void setup() {
// run once:
Serial.begin(9600);
pinMode(A0, OUTPUT);
pinMode(A1, OUTPUT);
pinMode(A2, OUTPUT);
pinMode(A3, OUTPUT);
pinMode(A4, OUTPUT);
pinMode(A5, OUTPUT);
pinMode(A6, OUTPUT);
pinMode(A7, OUTPUT);
pinMode(TRstepPin, OUTPUT);
pinMode(TRdirPin, OUTPUT);
pinMode(J1stepPin, OUTPUT);
pinMode(J1dirPin, OUTPUT);
pinMode(J2stepPin, OUTPUT);
pinMode(J2dirPin, OUTPUT);
pinMode(J3stepPin, OUTPUT);
pinMode(J3dirPin, OUTPUT);
pinMode(J4stepPin, OUTPUT);
pinMode(J4dirPin, OUTPUT);
pinMode(J5stepPin, OUTPUT);
pinMode(J5dirPin, OUTPUT);
pinMode(J6stepPin, OUTPUT);
pinMode(J6dirPin, OUTPUT);
pinMode(J1calPin, INPUT);
pinMode(J2calPin, INPUT);
pinMode(J3calPin, INPUT);
pinMode(J4calPin, INPUT);
pinMode(J5calPin, INPUT);
pinMode(J6calPin, INPUT);
pinMode(Input22, INPUT);
pinMode(Input23, INPUT);
pinMode(Input24, INPUT);
pinMode(Input25, INPUT);
pinMode(Input26, INPUT);
pinMode(Input27, INPUT);
pinMode(Input28, INPUT);
pinMode(Input29, INPUT);
pinMode(Input30, INPUT);
pinMode(Input31, INPUT);
pinMode(Input32, INPUT);
pinMode(Input33, INPUT);
pinMode(Input34, INPUT);
pinMode(Input35, INPUT);
pinMode(Input36, INPUT);
pinMode(Input37, INPUT);
pinMode(Output38, OUTPUT);
pinMode(Output39, OUTPUT);
pinMode(Output40, OUTPUT);
pinMode(Output41, OUTPUT);
pinMode(Output42, OUTPUT);
pinMode(Output43, OUTPUT);
pinMode(Output44, OUTPUT);
pinMode(Output45, OUTPUT);
pinMode(Output46, OUTPUT);
pinMode(Output47, OUTPUT);
pinMode(Output48, OUTPUT);
pinMode(Output49, OUTPUT);
pinMode(Output50, OUTPUT);
pinMode(Output51, OUTPUT);
pinMode(Output52, OUTPUT);
pinMode(Output53, OUTPUT);
servo0.attach(A0);
servo1.attach(A1);
servo2.attach(A2);
servo3.attach(A3);
servo4.attach(A4);
servo5.attach(A5);
servo6.attach(A6);
servo7.attach(A7);
digitalWrite(Output38, HIGH);
digitalWrite(Output39, HIGH);
digitalWrite(Output40, HIGH);
digitalWrite(Output41, HIGH);
digitalWrite(Output42, HIGH);
digitalWrite(Output43, HIGH);
digitalWrite(Output44, HIGH);
digitalWrite(Output45, HIGH);
digitalWrite(TRstepPin, HIGH);
digitalWrite(J1stepPin, HIGH);
digitalWrite(J2stepPin, HIGH);
digitalWrite(J3stepPin, HIGH);
digitalWrite(J4stepPin, HIGH);
digitalWrite(J5stepPin, HIGH);
digitalWrite(J6stepPin, HIGH);
}
void loop() {
//test led
if (digitalRead(J1calPin) == HIGH || digitalRead(J2calPin) == HIGH || digitalRead(J3calPin) == HIGH || digitalRead(J4calPin) == HIGH || digitalRead(J5calPin) == HIGH || digitalRead(J6calPin) == HIGH)
{
digitalWrite(J6dirPin, HIGH);
}
else
{
digitalWrite(J6dirPin, LOW);
}
while (Serial.available() > 0)
{
char recieved = Serial.read();
inData += recieved;
// Process message when new line character is recieved
if (recieved == '\\n')
{
String function = inData.substring(0, 2);
//-----COMMAND TO MOVE SERVO---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""SV"")
{
int SVstart = inData.indexOf('V');
int POSstart = inData.indexOf('P');
int servoNum = inData.substring(SVstart + 1, POSstart).toInt();
int servoPOS = inData.substring(POSstart + 1).toInt();
if (servoNum == 0)
{
servo0.write(servoPOS);
}
if (servoNum == 1)
{
servo1.write(servoPOS);
}
if (servoNum == 2)
{
servo2.write(servoPOS);
}
if (servoNum == 3)
{
servo3.write(servoPOS);
}
if (servoNum == 4)
{
servo4.write(servoPOS);
}
if (servoNum == 5)
{
servo5.write(servoPOS);
}
if (servoNum == 6)
{
servo6.write(servoPOS);
}
if (servoNum == 7)
{
servo7.write(servoPOS);
}
Serial.print(""Servo Done"");
}
//-----COMMAND TO WAIT TIME---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""WT"")
{
int WTstart = inData.indexOf('S');
float WaitTime = inData.substring(WTstart + 1).toFloat();
int WaitTimeMS = WaitTime * 1000;
delay(WaitTimeMS);
Serial.print(""Done"");
}
//-----COMMAND IF INPUT THEN JUMP---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""JF"")
{
int IJstart = inData.indexOf('X');
int IJTabstart = inData.indexOf('T');
int IJInputNum = inData.substring(IJstart + 1, IJTabstart).toInt();
if (digitalRead(IJInputNum) == HIGH)
{
Serial.println(""True\\n"");
}
if (digitalRead(IJInputNum) == LOW)
{
Serial.println(""False\\n"");
}
}
//-----COMMAND SET OUTPUT ON---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""ON"")
{
int ONstart = inData.indexOf('X');
int outputNum = inData.substring(ONstart + 1).toInt();
digitalWrite(outputNum, HIGH);
Serial.print(""Done"");
}
//-----COMMAND SET OUTPUT OFF---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""OF"")
{
int ONstart = inData.indexOf('X');
int outputNum = inData.substring(ONstart + 1).toInt();
digitalWrite(outputNum, LOW);
Serial.print(""Done"");
}
//-----COMMAND TO WAIT INPUT ON---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""WI"")
{
int WIstart = inData.indexOf('N');
int InputNum = inData.substring(WIstart + 1).toInt();
while (digitalRead(InputNum) == LOW) {
delay(100);
}
Serial.print(""Done"");
}
//-----COMMAND TO WAIT INPUT OFF---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""WO"")
{
int WIstart = inData.indexOf('N');
int InputNum = inData.substring(WIstart + 1).toInt();
//String InputStr = String(""Input"" + InputNum);
//uint8_t Input = atoi(InputStr.c_str ());
while (digitalRead(InputNum) == HIGH) {
delay(100);
}
Serial.print(""Done"");
}
//-----COMMAND TO CALIBRATE---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""LL"")
{
int J1start = inData.indexOf('A');
int J2start = inData.indexOf('B');
int J3start = inData.indexOf('C');
int J4start = inData.indexOf('D');
int J5start = inData.indexOf('E');
int J6start = inData.indexOf('F');
int SPstart = inData.indexOf('S');
///
int J1caldir = inData.substring(J1start + 1, J1start + 2).toInt();
int J2caldir = inData.substring(J2start + 1, J2start + 2).toInt();
int J3caldir = inData.substring(J3start + 1, J3start + 2).toInt();
int J4caldir = inData.substring(J4start + 1, J4start + 2).toInt();
int J5caldir = inData.substring(J5start + 1, J5start + 2).toInt();
int J6caldir = inData.substring(J6start + 1, J6start + 2).toInt();
///
int J1step = (inData.substring(J1start + 2, J2start).toInt());
int J2step = (inData.substring(J2start + 2, J3start).toInt());
int J3step = (inData.substring(J3start + 2, J4start).toInt());
int J4step = (inData.substring(J4start + 2, J5start).toInt());
int J5step = (inData.substring(J5start + 2, J6start).toInt());
int J6step = (inData.substring(J6start + 2).toInt());
///
float SpeedIn = inData.substring(SPstart + 1).toFloat();
//RESET COUNTERS
int J1done = 0;
int J2done = 0;
int J3done = 0;
int J4done = 0;
int J5done = 0;
int J6done = 0;
String J1calStat = ""0"";
//SET DIRECTIONS
// J1 //
if (J1rotdir == 1 && J1caldir == 1) {
digitalWrite(J1dirPin, LOW);
}
else if (J1rotdir == 0 && J1caldir == 1) {
digitalWrite(J1dirPin, HIGH);
}
else if (J1rotdir == 1 && J1caldir == 0) {
digitalWrite(J1dirPin, HIGH);
}
else if (J1rotdir == 0 && J1caldir == 0) {
digitalWrite(J1dirPin, LOW);
}
// J2 //
if (J2rotdir == 1 && J2caldir == 1) {
digitalWrite(J2dirPin, LOW);
}
else if (J2rotdir == 0 && J2caldir == 1) {
digitalWrite(J2dirPin, HIGH);
}
else if (J2rotdir == 1 && J2caldir == 0) {
digitalWrite(J2dirPin, HIGH);
}
else if (J2rotdir == 0 && J2caldir == 0) {
digitalWrite(J2dirPin, LOW);
}
// J3 //
if (J3rotdir == 1 && J3caldir == 1) {
digitalWrite(J3dirPin, LOW);
}
else if (J3rotdir == 0 && J3caldir == 1) {
digitalWrite(J3dirPin, HIGH);
}
else if (J3rotdir == 1 && J3caldir == 0) {
digitalWrite(J3dirPin, HIGH);
}
else if (J3rotdir == 0 && J3caldir == 0) {
digitalWrite(J3dirPin, LOW);
}
// J4 //
if (J4rotdir == 1 && J4caldir == 1) {
digitalWrite(J4dirPin, LOW);
}
else if (J4rotdir == 0 && J4caldir == 1) {
digitalWrite(J4dirPin, HIGH);
}
else if (J4rotdir == 1 && J4caldir == 0) {
digitalWrite(J4dirPin, HIGH);
}
else if (J4rotdir == 0 && J4caldir == 0) {
digitalWrite(J4dirPin, LOW);
}
// J5 //
if (J5rotdir == 1 && J5caldir == 1) {
digitalWrite(J5dirPin, LOW);
}
else if (J5rotdir == 0 && J5caldir == 1) {
digitalWrite(J5dirPin, HIGH);
}
else if (J5rotdir == 1 && J5caldir == 0) {
digitalWrite(J5dirPin, HIGH);
}
else if (J5rotdir == 0 && J5caldir == 0) {
digitalWrite(J5dirPin, LOW);
}
// J6 //
if (J6rotdir == 1 && J6caldir == 1) {
digitalWrite(J6dirPin, LOW);
}
else if (J6rotdir == 0 && J6caldir == 1) {
digitalWrite(J6dirPin, HIGH);
}
else if (J6rotdir == 1 && J6caldir == 0) {
digitalWrite(J6dirPin, HIGH);
}
else if (J6rotdir == 0 && J6caldir == 0) {
digitalWrite(J6dirPin, LOW);
}
float AdjSpeed = (SpeedIn / 100);
float CalcRegSpeed = ((SpeedMult * 2) / AdjSpeed);
int Speed = int(CalcRegSpeed);
//DRIVE MOTORS FOR CALIBRATION
while (digitalRead(J1calPin) == LOW && J1done < J1step || digitalRead(J2calPin) == LOW && J2done < J2step || digitalRead(J3calPin) == LOW && J3done < J3step || digitalRead(J4calPin) == LOW && J4done < J4step || digitalRead(J5calPin) == LOW && J5done < J5step || digitalRead(J6calPin) == LOW && J6done < J6step)
{
if (J1done < J1step && (digitalRead(J1calPin) == LOW))
{
digitalWrite(J1stepPin, LOW);
}
delayMicroseconds(5);
if (J1done < J1step && (digitalRead(J1calPin) == LOW))
{
digitalWrite(J1stepPin, HIGH);
J1done = ++J1done;
}
delayMicroseconds(5);
if (J2done < J2step && (digitalRead(J2calPin) == LOW))
{
digitalWrite(J2stepPin, LOW);
}
delayMicroseconds(5);
if (J2done < J2step && (digitalRead(J2calPin) == LOW))
{
digitalWrite(J2stepPin, HIGH);
J2done = ++J2done;
}
delayMicroseconds(5);
if (J3done < J3step && (digitalRead(J3calPin) == LOW))
{
digitalWrite(J3stepPin, LOW);
}
delayMicroseconds(5);
if (J3done < J3step && (digitalRead(J3calPin) == LOW))
{
digitalWrite(J3stepPin, HIGH);
J3done = ++J3done;
}
delayMicroseconds(5);
if (J4done < J4step && (digitalRead(J4calPin) == LOW))
{
digitalWrite(J4stepPin, LOW);
}
delayMicroseconds(5);
if (J4done < J4step && (digitalRead(J4calPin) == LOW))
{
digitalWrite(J4stepPin, HIGH);
J4done = ++J4done;
}
delayMicroseconds(5);
if (J5done < J5step && (digitalRead(J5calPin) == LOW))
{
digitalWrite(J5stepPin, LOW);
}
delayMicroseconds(5);
if (J5done < J5step && (digitalRead(J5calPin) == LOW))
{
digitalWrite(J5stepPin, HIGH);
J5done = ++J5done;;
}
delayMicroseconds(5);
if (J6done < J6step && (digitalRead(J6calPin) == LOW))
{
digitalWrite(J6stepPin, LOW);
}
delayMicroseconds(5);
if (J6done < J6step && (digitalRead(J6calPin) == LOW))
{
digitalWrite(J6stepPin, HIGH);
J6done = ++J6done;
}
///////////////DELAY BEFORE RESTARTING LOOP
delayMicroseconds(Speed);
}
//OVERDRIVE
int OvrDrv = 0;
while (OvrDrv <= 20)
{
if (J1step > 0)
{
digitalWrite(J1stepPin, LOW);
}
if (J2step > 0)
{
digitalWrite(J2stepPin, LOW);
}
if (J3step > 0)
{
digitalWrite(J3stepPin, LOW);
}
if (J4step > 0)
{
digitalWrite(J4stepPin, LOW);
}
if (J5step > 0)
{
digitalWrite(J5stepPin, LOW);
}
if (J6step > 0)
{
digitalWrite(J6stepPin, LOW);
}
///////////////DELAY AND SET HIGH
delayMicroseconds(Speed);
if (J1step > 0)
{
digitalWrite(J1stepPin, HIGH);
}
if (J2step > 0)
{
digitalWrite(J2stepPin, HIGH);
}
if (J3step > 0)
{
digitalWrite(J3stepPin, HIGH);
}
if (J4step > 0)
{
digitalWrite(J4stepPin, HIGH);
}
if (J5step > 0)
{
digitalWrite(J5stepPin, HIGH);
}
if (J6step > 0)
{
digitalWrite(J6stepPin, HIGH);
}
OvrDrv = ++OvrDrv;
///////////////DELAY BEFORE RESTARTING LOOP AND SETTING LOW AGAIN
delayMicroseconds(Speed);
}
//SEE IF ANY SWITCHES NOT MADE
delay(500);
///
int J1pass = 1;
int J2pass = 1;
int J3pass = 1;
int J4pass = 1;
int J5pass = 1;
int J6pass = 1;
///
if (J1step > 0) {
if (digitalRead(J1calPin) == LOW) {
J1pass = 0;
}
}
if (J2step > 0) {
if (digitalRead(J2calPin) == LOW) {
J2pass = 0;
}
}
if (J3step > 0) {
if (digitalRead(J3calPin) == LOW) {
J3pass = 0;
}
}
if (J4step > 0) {
if (digitalRead(J4calPin) == LOW) {
J4pass = 0;
}
}
if (J5step > 0)
{ if (digitalRead(J5calPin) == LOW) {
J5pass = 0;
}
}
if (J6step > 0)
{ if (digitalRead(J6calPin) == LOW) {
J6pass = 0;
}
}
if ((J1pass + J2pass + J3pass + J4pass + J5pass + J6pass) == 6)
{
Serial.println(""pass\\n"");
}
else
{
Serial.println(""fail\\n"");
}
inData = """"; // Clear recieved buffer
}
//-----COMMAND TO MOVE---------------------------------------------------
//-----------------------------------------------------------------------
if (function == ""MJ"")
{
int J1start = inData.indexOf('A');
int J2start = inData.indexOf('B');
int J3start = inData.indexOf('C');
int J4start = inData.indexOf('D');
int J5start = inData.indexOf('E');
int J6start = inData.indexOf('F');
int TRstart = inData.indexOf('T');
int Adstart = inData.indexOf('G');
int Asstart = inData.indexOf('H');
int Ddstart = inData.indexOf('I');
int Dsstart = inData.indexOf('K');
int SPstart = inData.indexOf('S');
int J1dir = inData.substring(J1start + 1, J1start + 2).toInt();
int J2dir = inData.substring(J2start + 1, J2start + 2).toInt();
int J3dir = inData.substring(J3start + 1, J3start + 2).toInt();
int J4dir = inData.substring(J4start + 1, J4start + 2).toInt();
int J5dir = inData.substring(J5start + 1, J5start + 2).toInt();
int J6dir = inData.substring(J6start + 1, J6start + 2).toInt();
int TRdir = inData.substring(TRstart + 1, TRstart + 2).toInt();
int J1step = inData.substring(J1start + 2, J2start).toInt();
int J2step = inData.substring(J2start + 2, J3start).toInt();
int J3step = inData.substring(J3start + 2, J4start).toInt();
int J4step = inData.substring(J4start + 2, J5start).toInt();
int J5step = inData.substring(J5start + 2, J6start).toInt();
int J6step = inData.substring(J6start + 2, TRstart).toInt();
int TRstep = inData.substring(TRstart + 2, SPstart).toInt();
float SpeedIn = inData.substring(SPstart + 1, Adstart).toFloat();
float ACCdur = inData.substring(Adstart + 1, Asstart).toInt();
float ACCspd = inData.substring(Asstart + 1, Ddstart).toInt();
float DCCdur = inData.substring(Ddstart + 1, Dsstart).toInt();
float DCCspd = inData.substring(Dsstart + 1).toInt();
Serial.print(""command recieved"");
//FIND HIGHEST STEP
int HighStep = J1step;
if (J2step > HighStep)
{
HighStep = J2step;
}
if (J3step > HighStep)
{
HighStep = J3step;
}
if (J4step > HighStep)
{
HighStep = J4step;
}
if (J5step > HighStep)
{
HighStep = J5step;
}
if (J6step > HighStep)
{
HighStep = J6step;
}
if (TRstep > HighStep)
{
HighStep = TRstep;
}
//FIND ACTIVE JOINTS
int J1active = 0;
int J2active = 0;
int J3active = 0;
int J4active = 0;
int J5active = 0;
int J6active = 0;
int TRactive = 0;
int Jactive = 0;
if (J1step >= 1)
{
J1active = 1;
}
if (J2step >= 1)
{
J2active = 1;
}
if (J3step >= 1)
{
J3active = 1;
}
if (J4step >= 1)
{
J4active = 1;
}
if (J5step >= 1)
{
J5active = 1;
}
if (J6step >= 1)
{
J6active = 1;
}
if (TRstep >= 1)
{
TRactive = 1;
}
Jactive = (J1active + J2active + J3active + J4active + J5active + J6active + TRactive);
int J1_PE = 0;
int J2_PE = 0;
int J3_PE = 0;
int J4_PE = 0;
int J5_PE = 0;
int J6_PE = 0;
int TR_PE = 0;
int J1_SE_1 = 0;
int J2_SE_1 = 0;
int J3_SE_1 = 0;
int J4_SE_1 = 0;
int J5_SE_1 = 0;
int J6_SE_1 = 0;
int TR_SE_1 = 0;
int J1_SE_2 = 0;
int J2_SE_2 = 0;
int J3_SE_2 = 0;
int J4_SE_2 = 0;
int J5_SE_2 = 0;
int J6_SE_2 = 0;
int TR_SE_2 = 0;
int J1_LO_1 = 0;
int J2_LO_1 = 0;
int J3_LO_1 = 0;
int J4_LO_1 = 0;
int J5_LO_1 = 0;
int J6_LO_1 = 0;
int TR_LO_1 = 0;
int J1_LO_2 = 0;
int J2_LO_2 = 0;
int J3_LO_2 = 0;
int J4_LO_2 = 0;
int J5_LO_2 = 0;
int J6_LO_2 = 0;
int TR_LO_2 = 0;
//reset
int J1cur = 0;
int J2cur = 0;
int J3cur = 0;
int J4cur = 0;
int J5cur = 0;
int J6cur = 0;
int TRcur = 0;
int J1_PEcur = 0;
int J2_PEcur = 0;
int J3_PEcur = 0;
int J4_PEcur = 0;
int J5_PEcur = 0;
int J6_PEcur = 0;
int TR_PEcur = 0;
int J1_SE_1cur = 0;
int J2_SE_1cur = 0;
int J3_SE_1cur = 0;
int J4_SE_1cur = 0;
int J5_SE_1cur = 0;
int J6_SE_1cur = 0;
int TR_SE_1cur = 0;
int J1_SE_2cur = 0;
int J2_SE_2cur = 0;
int J3_SE_2cur = 0;
int J4_SE_2cur = 0;
int J5_SE_2cur = 0;
int J6_SE_2cur = 0;
int TR_SE_2cur = 0;
int highStepCur = 0;
float curDelay = 0;
//SET DIRECTIONS
/////// J1 /////////
if (J1dir == 1 && J1rotdir == 1)
{
digitalWrite(J1dirPin, LOW);
}
else if (J1dir == 1 && J1rotdir == 0)
{
digitalWrite(J1dirPin, HIGH);
}
else if (J1dir == 0 && J1rotdir == 1)
{
digitalWrite(J1dirPin, HIGH);
}
else if (J1dir == 0 && J1rotdir == 0)
{
digitalWrite(J1dirPin, LOW);
}
/////// J2 /////////
if (J2dir == 1 && J2rotdir == 1)
{
digitalWrite(J2dirPin, LOW);
}
else if (J2dir == 1 && J2rotdir == 0)
{
digitalWrite(J2dirPin, HIGH);
}
else if (J2dir == 0 && J2rotdir == 1)
{
digitalWrite(J2dirPin, HIGH);
}
else if (J2dir == 0 && J2rotdir == 0)
{
digitalWrite(J2dirPin, LOW);
}
/////// J3 /////////
if (J3dir == 1 && J3rotdir == 1)
{
digitalWrite(J3dirPin, LOW);
}
else if (J3dir == 1 && J3rotdir == 0)
{
digitalWrite(J3dirPin, HIGH);
}
else if (J3dir == 0 && J3rotdir == 1)
{
digitalWrite(J3dirPin, HIGH);
}
else if (J3dir == 0 && J3rotdir == 0)
{
digitalWrite(J3dirPin, LOW);
}
/////// J4 /////////
if (J4dir == 1 && J4rotdir == 1)
{
digitalWrite(J4dirPin, LOW);
}
else if (J4dir == 1 && J4rotdir == 0)
{
digitalWrite(J4dirPin, HIGH);
}
else if (J4dir == 0 && J4rotdir == 1)
{
digitalWrite(J4dirPin, HIGH);
}
else if (J4dir == 0 && J4rotdir == 0)
{
digitalWrite(J4dirPin, LOW);
}
/////// J5 /////////
if (J5dir == 1 && J5rotdir == 1)
{
digitalWrite(J5dirPin, LOW);
}
else if (J5dir == 1 && J5rotdir == 0)
{
digitalWrite(J5dirPin, HIGH);
}
else if (J5dir == 0 && J5rotdir == 1)
{
digitalWrite(J5dirPin, HIGH);
}
else if (J5dir == 0 && J5rotdir == 0)
{
digitalWrite(J5dirPin, LOW);
}
/////// J6 /////////
if (J6dir == 1 && J6rotdir == 1)
{
digitalWrite(J6dirPin, LOW);
}
else if (J6dir == 1 && J6rotdir == 0)
{
digitalWrite(J6dirPin, HIGH);
}
else if (J6dir == 0 && J6rotdir == 1)
{
digitalWrite(J6dirPin, HIGH);
}
else if (J6dir == 0 && J6rotdir == 0)
{
digitalWrite(J6dirPin, LOW);
}
/////// TRACK /////////
if (TRdir == 1 && TRACKrotdir == 1)
{
digitalWrite(TRdirPin, LOW);
}
else if (TRdir == 1 && TRACKrotdir == 0)
{
digitalWrite(TRdirPin, HIGH);
}
else if (TRdir == 0 && TRACKrotdir == 1)
{
digitalWrite(TRdirPin, HIGH);
}
else if (TRdir == 0 && TRACKrotdir == 0)
{
digitalWrite(TRdirPin, LOW);
}
/////CALC SPEEDS//////
float ACCStep = (HighStep * (ACCdur / 100));
float DCCStep = HighStep - (HighStep * (DCCdur / 100));
float AdjSpeed = (SpeedIn / 100);
//REG SPEED
float CalcRegSpeed = (SpeedMult / AdjSpeed);
int REGSpeed = int(CalcRegSpeed);
//ACC SPEED
float ACCspdT = (ACCspd / 100);
float CalcACCSpeed = ((SpeedMult + (SpeedMult / ACCspdT)) / AdjSpeed);
float ACCSpeed = (CalcACCSpeed);
float ACCinc = (REGSpeed - ACCSpeed) / ACCStep;
//DCC SPEED
float DCCspdT = (DCCspd / 100);
float CalcDCCSpeed = ((SpeedMult + (SpeedMult / DCCspdT)) / AdjSpeed);
float DCCSpeed = (CalcDCCSpeed);
float DCCinc = (REGSpeed + DCCSpeed) / DCCStep;
DCCSpeed = REGSpeed;
///// DRIVE MOTORS /////
while (J1cur < J1step || J2cur < J2step || J3cur < J3step || J4cur < J4step || J5cur < J5step || J6cur < J6step || TRcur < TRstep)
{
////DELAY CALC/////
if (highStepCur <= ACCStep)
{
curDelay = (ACCSpeed / Jactive);
ACCSpeed = ACCSpeed + ACCinc;
}
else if (highStepCur >= DCCStep)
{
curDelay = (DCCSpeed / Jactive);
DCCSpeed = DCCSpeed + DCCinc;
}
else
{
curDelay = (REGSpeed / Jactive);
}
/////// J1 ////////////////////////////////
///find pulse every
if (J1cur < J1step)
{
J1_PE = (HighStep / J1step);
///find left over 1
J1_LO_1 = (HighStep - (J1step * J1_PE));
///find skip 1
if (J1_LO_1 > 0)
{
J1_SE_1 = (HighStep / J1_LO_1);
}
else
{
J1_SE_1 = 0;
}
///find left over 2
if (J1_SE_1 > 0)
{
J1_LO_2 = HighStep - ((J1step * J1_PE) + ((J1step * J1_PE) / J1_SE_1));
}
else
{
J1_LO_2 = 0;
}
///find skip 2
if (J1_LO_2 > 0)
{
J1_SE_2 = (HighStep / J1_LO_2);
}
else
{
J1_SE_2 = 0;
}
///////// J1 ///////////////
if (J1_SE_2 == 0)
{
J1_SE_2cur = (J1_SE_2 + 1);
}
if (J1_SE_2cur != J1_SE_2)
{
J1_SE_2cur = ++J1_SE_2cur;
if (J1_SE_1 == 0)
{
J1_SE_1cur = (J1_SE_1 + 1);
}
if (J1_SE_1cur != J1_SE_1)
{
J1_SE_1cur = ++J1_SE_1cur;
J1_PEcur = ++J1_PEcur;
if (J1_PEcur == J1_PE)
{
J1cur = ++J1cur;
J1_PEcur = 0;
digitalWrite(J1stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J1stepPin, HIGH);
}
}
else
{
J1_SE_1cur = 0;
}
}
else
{
J1_SE_2cur = 0;
}
}
/////// J2 ////////////////////////////////
///find pulse every
if (J2cur < J2step)
{
J2_PE = (HighStep / J2step);
///find left over 1
J2_LO_1 = (HighStep - (J2step * J2_PE));
///find skip 1
if (J2_LO_1 > 0)
{
J2_SE_1 = (HighStep / J2_LO_1);
}
else
{
J2_SE_1 = 0;
}
///find left over 2
if (J2_SE_1 > 0)
{
J2_LO_2 = HighStep - ((J2step * J2_PE) + ((J2step * J2_PE) / J2_SE_1));
}
else
{
J2_LO_2 = 0;
}
///find skip 2
if (J2_LO_2 > 0)
{
J2_SE_2 = (HighStep / J2_LO_2);
}
else
{
J2_SE_2 = 0;
}
///////// J2 ///////////////
if (J2_SE_2 == 0)
{
J2_SE_2cur = (J2_SE_2 + 1);
}
if (J2_SE_2cur != J2_SE_2)
{
J2_SE_2cur = ++J2_SE_2cur;
if (J2_SE_1 == 0)
{
J2_SE_1cur = (J2_SE_1 + 1);
}
if (J2_SE_1cur != J2_SE_1)
{
J2_SE_1cur = ++J2_SE_1cur;
J2_PEcur = ++J2_PEcur;
if (J2_PEcur == J2_PE)
{
J2cur = ++J2cur;
J2_PEcur = 0;
digitalWrite(J2stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J2stepPin, HIGH);
}
}
else
{
J2_SE_1cur = 0;
}
}
else
{
J2_SE_2cur = 0;
}
}
/////// J3 ////////////////////////////////
///find pulse every
if (J3cur < J3step)
{
J3_PE = (HighStep / J3step);
///find left over 1
J3_LO_1 = (HighStep - (J3step * J3_PE));
///find skip 1
if (J3_LO_1 > 0)
{
J3_SE_1 = (HighStep / J3_LO_1);
}
else
{
J3_SE_1 = 0;
}
///find left over 2
if (J3_SE_1 > 0)
{
J3_LO_2 = HighStep - ((J3step * J3_PE) + ((J3step * J3_PE) / J3_SE_1));
}
else
{
J3_LO_2 = 0;
}
///find skip 2
if (J3_LO_2 > 0)
{
J3_SE_2 = (HighStep / J3_LO_2);
}
else
{
J3_SE_2 = 0;
}
///////// J3 ///////////////
if (J3_SE_2 == 0)
{
J3_SE_2cur = (J3_SE_2 + 1);
}
if (J3_SE_2cur != J3_SE_2)
{
J3_SE_2cur = ++J3_SE_2cur;
if (J3_SE_1 == 0)
{
J3_SE_1cur = (J3_SE_1 + 1);
}
if (J3_SE_1cur != J3_SE_1)
{
J3_SE_1cur = ++J3_SE_1cur;
J3_PEcur = ++J3_PEcur;
if (J3_PEcur == J3_PE)
{
J3cur = ++J3cur;
J3_PEcur = 0;
digitalWrite(J3stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J3stepPin, HIGH);
}
}
else
{
J3_SE_1cur = 0;
}
}
else
{
J3_SE_2cur = 0;
}
}
/////// J4 ////////////////////////////////
///find pulse every
if (J4cur < J4step)
{
J4_PE = (HighStep / J4step);
///find left over 1
J4_LO_1 = (HighStep - (J4step * J4_PE));
///find skip 1
if (J4_LO_1 > 0)
{
J4_SE_1 = (HighStep / J4_LO_1);
}
else
{
J4_SE_1 = 0;
}
///find left over 2
if (J4_SE_1 > 0)
{
J4_LO_2 = HighStep - ((J4step * J4_PE) + ((J4step * J4_PE) / J4_SE_1));
}
else
{
J4_LO_2 = 0;
}
///find skip 2
if (J4_LO_2 > 0)
{
J4_SE_2 = (HighStep / J4_LO_2);
}
else
{
J4_SE_2 = 0;
}
///////// J4 ///////////////
if (J4_SE_2 == 0)
{
J4_SE_2cur = (J4_SE_2 + 1);
}
if (J4_SE_2cur != J4_SE_2)
{
J4_SE_2cur = ++J4_SE_2cur;
if (J4_SE_1 == 0)
{
J4_SE_1cur = (J4_SE_1 + 1);
}
if (J4_SE_1cur != J4_SE_1)
{
J4_SE_1cur = ++J4_SE_1cur;
J4_PEcur = ++J4_PEcur;
if (J4_PEcur == J4_PE)
{
J4cur = ++J4cur;
J4_PEcur = 0;
digitalWrite(J4stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J4stepPin, HIGH);
}
}
else
{
J4_SE_1cur = 0;
}
}
else
{
J4_SE_2cur = 0;
}
}
/////// J5 ////////////////////////////////
///find pulse every
if (J5cur < J5step)
{
J5_PE = (HighStep / J5step);
///find left over 1
J5_LO_1 = (HighStep - (J5step * J5_PE));
///find skip 1
if (J5_LO_1 > 0)
{
J5_SE_1 = (HighStep / J5_LO_1);
}
else
{
J5_SE_1 = 0;
}
///find left over 2
if (J5_SE_1 > 0)
{
J5_LO_2 = HighStep - ((J5step * J5_PE) + ((J5step * J5_PE) / J5_SE_1));
}
else
{
J5_LO_2 = 0;
}
///find skip 2
if (J5_LO_2 > 0)
{
J5_SE_2 = (HighStep / J5_LO_2);
}
else
{
J5_SE_2 = 0;
}
///////// J5 ///////////////
if (J5_SE_2 == 0)
{
J5_SE_2cur = (J5_SE_2 + 1);
}
if (J5_SE_2cur != J5_SE_2)
{
J5_SE_2cur = ++J5_SE_2cur;
if (J5_SE_1 == 0)
{
J5_SE_1cur = (J5_SE_1 + 1);
}
if (J5_SE_1cur != J5_SE_1)
{
J5_SE_1cur = ++J5_SE_1cur;
J5_PEcur = ++J5_PEcur;
if (J5_PEcur == J5_PE)
{
J5cur = ++J5cur;
J5_PEcur = 0;
digitalWrite(J5stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J5stepPin, HIGH);
}
}
else
{
J5_SE_1cur = 0;
}
}
else
{
J5_SE_2cur = 0;
}
}
/////// J6 ////////////////////////////////
///find pulse every
if (J6cur < J6step)
{
J6_PE = (HighStep / J6step);
///find left over 1
J6_LO_1 = (HighStep - (J6step * J6_PE));
///find skip 1
if (J6_LO_1 > 0)
{
J6_SE_1 = (HighStep / J6_LO_1);
}
else
{
J6_SE_1 = 0;
}
///find left over 2
if (J6_SE_1 > 0)
{
J6_LO_2 = HighStep - ((J6step * J6_PE) + ((J6step * J6_PE) / J6_SE_1));
}
else
{
J6_LO_2 = 0;
}
///find skip 2
if (J6_LO_2 > 0)
{
J6_SE_2 = (HighStep / J6_LO_2);
}
else
{
J6_SE_2 = 0;
}
///////// J6 ///////////////
if (J6_SE_2 == 0)
{
J6_SE_2cur = (J6_SE_2 + 1);
}
if (J6_SE_2cur != J6_SE_2)
{
J6_SE_2cur = ++J6_SE_2cur;
if (J6_SE_1 == 0)
{
J6_SE_1cur = (J6_SE_1 + 1);
}
if (J6_SE_1cur != J6_SE_1)
{
J6_SE_1cur = ++J6_SE_1cur;
J6_PEcur = ++J6_PEcur;
if (J6_PEcur == J6_PE)
{
J6cur = ++J6cur;
J6_PEcur = 0;
digitalWrite(J6stepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(J6stepPin, HIGH);
}
}
else
{
J6_SE_1cur = 0;
}
}
else
{
J6_SE_2cur = 0;
}
}
/////// TR ////////////////////////////////
///find pulse every
if (TRcur < TRstep)
{
TR_PE = (HighStep / TRstep);
///find left over 1
TR_LO_1 = (HighStep - (TRstep * TR_PE));
///find skip 1
if (TR_LO_1 > 0)
{
TR_SE_1 = (HighStep / TR_LO_1);
}
else
{
TR_SE_1 = 0;
}
///find left over 2
if (TR_SE_1 > 0)
{
TR_LO_2 = HighStep - ((TRstep * TR_PE) + ((TRstep * TR_PE) / TR_SE_1));
}
else
{
TR_LO_2 = 0;
}
///find skip 2
if (TR_LO_2 > 0)
{
TR_SE_2 = (HighStep / TR_LO_2);
}
else
{
TR_SE_2 = 0;
}
///////// TR ///////////////
if (TR_SE_2 == 0)
{
TR_SE_2cur = (TR_SE_2 + 1);
}
if (TR_SE_2cur != TR_SE_2)
{
TR_SE_2cur = ++TR_SE_2cur;
if (TR_SE_1 == 0)
{
TR_SE_1cur = (TR_SE_1 + 1);
}
if (TR_SE_1cur != TR_SE_1)
{
TR_SE_1cur = ++TR_SE_1cur;
TR_PEcur = ++TR_PEcur;
if (TR_PEcur == TR_PE)
{
TRcur = ++TRcur;
TR_PEcur = 0;
digitalWrite(TRstepPin, LOW);
delayMicroseconds(curDelay);
digitalWrite(TRstepPin, HIGH);
}
}
else
{
TR_SE_1cur = 0;
}
}
else
{
TR_SE_2cur = 0;
}
}
// inc cur step
highStepCur = ++highStepCur;
}
////////MOVE COMPLETE///////////
inData = """"; // Clear recieved buffer
//Serial.print(""Move Done"");
}
else
{
inData = """"; // Clear recieved buffer
}
}
}
}
",12404,False,2310.8491652197545,median
"/*
FlipMode.ino
Test flip functionality (180 degree roation)
Note: Not supported with all displays
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#ifdef U8X8_HAVE_HW_SPI
#include
#endif
// Please UNCOMMENT one of the contructor lines below
// U8x8 Contructor List
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8x8setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8X8_NULL u8x8; // null device, a 8x8 pixel display which does nothing
//U8X8_SSD1306_128X64_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 6, /* dc=*/ 4, /* reset=*/ 12); // Arduboy (DevKit)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6); // Arduboy 10 (Production, Kickstarter Edition)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_3W_HW_SPI u8x8(/* cs=*/ 10, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_128X64_ALT0_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ 2, /* data=*/ 0, /* reset=*/ U8X8_PIN_NONE); // Digispark ATTiny85
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // OLEDs without Reset of the Display
//U8X8_SSD1306_128X64_VCOMH0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8X8_SSD1306_128X64_ALT0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8X8_SSD1306_102X64_EA_OLEDS102_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8X8_SH1106_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1106_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1106_128X64_VCOMH0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8X8_SH1106_128X64_WINSTAR_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but uses updated SH1106 init sequence
//U8X8_SH1106_128X32_VISIONOX_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1106_128X32_VISIONOX_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1106_72X40_WISE_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_64X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_128X128_HW_I2C u8x8(/* reset=*/ 8);
//U8X8_SH1107_PIMORONI_128X128_HW_I2C u8x8(/* reset=*/ 8);
//U8X8_SH1107_SEEED_128X128_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1107_SEEED_128X128_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1107_SEEED_96X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1108_160X160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8X8_SSD1306_128X32_WINSTAR_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8X8_SSD1306_64X48_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8X8_SSD1306_48X64_WINSTAR_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_64X32_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_64X32_1F_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_96X16_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.69""
//U8X8_SSD1306_72X40_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.42""
//U8X8_SSD1306_128X64_NONAME_6800 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_8080 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME0_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME2_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME2_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1316_128X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1316_128X32_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1317_96X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // not tested, not confirmed
//U8X8_SSD1317_96X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // not tested, not confirmed
//U8X8_SSD1318_128X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1318_128X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1320_160X132_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1320_160X132_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_256X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_256X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1325_NHD_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1325_NHD_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD0323_OS128064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD0323_OS128064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1326_ER_256X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // experimental driver for ER-OLED018-1
//U8X8_SSD1327_SEEED_96X96_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8X8_SSD1327_SEEED_96X96_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8X8_SSD1327_EA_W128128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_EA_W128128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_MIDAS_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_MIDAS_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_WS_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_WS_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_VISIONOX_128X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_VISIONOX_128X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_128X96_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_128X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ A4, /* dc=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather 32u4 Basic Proto
//U8X8_SSD1305_128X32_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_ADAFRUIT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_ADAFRUIT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_ADAFRUIT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_ADAFRUIT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_RAYSTAR_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_RAYSTAR_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_KS0108_128X64 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_KS0108_ERM19264 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_HD44102_100X64 u8x8(4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_T7932_150X32 u8x8(4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_UC1701_EA_DOGS102_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1701_EA_DOGS102_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_PCD8544_84X48_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8X8_PCD8544_84X48_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8X8_PCF8812_96X65_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8X8_PCF8812_96X65_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8X8_HX1230_96X68_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_HX1230_96X68_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7528_ERC16064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7528_ERC16064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_64128N_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_64128N_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM132_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8X8_ST7565_EA_DOGM132_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8X8_ST7565_ZOLEN_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ZOLEN_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_LM6059_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8X8_ST7565_LM6059_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8X8_ST7565_KS0713_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // KS0713 controller
//U8X8_ST7565_KS0713_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // KS0713 controller
//U8X8_ST7565_LX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_LX12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_ALT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8X8_ST7565_ERC12864_ALT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8X8_ST7565_NHD_C12832_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12832_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_JLX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_JLX12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_PI_132X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8X8_ST7567_PI_132X64_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8X8_ST7567_JLX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_JLX12864_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_OS12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_OS12864_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064I_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064I_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_64X32_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_ST7567_HEM6432_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_ST7571_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7571_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7571_128X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7571_128X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX172104_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX172104_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX19296_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX19296_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_WO256X128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_WO256X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160M_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160M_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_ALT_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_ALT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX240160_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX240160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX25664_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C
//U8X8_ST75320_JLX320240_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75320_JLX320240_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_NT7534_TG12864R_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_NT7534_TG12864R_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7588_JLX12864_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
//U8X8_ST7588_JLX12864_HW_I2C u8x8(/* reset=*/ 5);
//U8X8_IST3020_ERC19264_6800 u8x8(44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8X8_IST3020_ERC19264_8080 u8x8(44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8X8_IST3020_ERC19264_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_IST7920_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Round display
//U8X8_IST7920_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Round display
//U8X8_UC1601_128X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1601_128X32_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_UC1601_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1604_JLX19264_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1604_JLX19264_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1608_ERC24064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, ERC24064-1 Test Board
//U8X8_UC1608_DEM240064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, ERC24064-1 Test Board
//U8X8_UC1608_ERC240120_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1608_240X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1610_EA_DOGXL160_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8X8_UC1610_EA_DOGXL160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8X8_UC1611_EA_DOGM240_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C, DOGM240 Test Board
//U8X8_UC1611_EA_DOGM240_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8X8_UC1611_EA_DOGXL240_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C, DOGXL240 Test Board
//U8X8_UC1611_EA_DOGXL240_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8X8_UC1611_IDS4073_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1611_IDS4073_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1611_EW50850_8080 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8X8_UC1611_CG160160_8080 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8X8_UC1617_JLX128128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1617_JLX128128_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_SW_I2C u8x8(/* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8); // u8g2 test board: I2C clock/data is same as SPI, I2C default address is 0x78
//U8X8_SSD1606_172X72_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display
//U8X8_SSD1607_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT from embedded artists
//U8X8_SSD1607_GS_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Good Display
//U8X8_SSD1607_WS_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Waveshare
//U8X8_IL3820_296X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT
//U8X8_IL3820_V2_296X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, optimized (lesser screen flicker)
//U8X8_ST7511_AVD_320X240_8080 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Connect RD pin with 3.3V/5V
//U8X8_S1D15721_240X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_S1D15721_240X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
// End of constructor list
void setup(void)
{
/* U8g2 Project: Pax Instruments Shield: Enable Backlight */
//pinMode(6, OUTPUT);
//digitalWrite(6, 0);
u8x8.begin();
}
void loop(void)
{
u8x8.setFont(u8x8_font_chroma48medium8_r);
u8x8.clear();
u8x8.setFlipMode(0);
u8x8.setInverseFont(1);
u8x8.drawString(0,0,""FlipMode 0"");
u8x8.setInverseFont(0);
u8x8.drawString(1,1,""FlipMode 0"");
delay(1500);
u8x8.clear();
u8x8.setFlipMode(1);
u8x8.setInverseFont(1);
u8x8.drawString(0,0,""FlipMode 1"");
u8x8.setInverseFont(0);
u8x8.drawString(1,1,""FlipMode 1"");
delay(1500);
}
",12411,True,3759.494063492824,median
"/**
* @par Copyright (C): 2010-2019, Shenzhen Yahboom Tech
* @file arduino_4WD_McNamee-wheel_Bluetooth_control_OLED
* @author wusicaijuan
* @version V1.0
* @date 2019.07.01
* @brief 蓝牙控制arduino4WD小车
* @details
* @par History 见如下说明
*
*/
#include
#include
#include //库文件
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
#define SERVOMIN 150 // this is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX 600 // this is the 'maximum' pulse length count (out of 4096)
#define PIN 9 //定义RGB灯的引脚
#define MAX_LED 4 //小车一共有1个RGB灯
Adafruit_NeoPixel strip = Adafruit_NeoPixel(MAX_LED, PIN, NEO_RGB + NEO_KHZ800);
#define run_car '1' //按键前
#define back_car '2' //按键后
#define left_car '3' //按键左
#define right_car '4' //按键右
#define stop_car '0' //按键停
#define ON 1 //使能LED
#define OFF 0 //禁止LED
/*小车运行状态枚举*/
const typedef enum {
enSTOP = 0,
enRUN,
enBACK,
enLEFT,
enRIGHT,
enTLEFT,
enTRIGHT
} enCarState;
const char enServo[] = {0, 1, 2, 3};
const int key = 8; //按键key
const int buzzer = 10; //设置控制蜂鸣器的引脚
//循迹红外引脚定义
//TrackSensorLeftPin1 TrackSensorLeftPin2 TrackSensorRightPin1 TrackSensorRightPin2
// A2 A1 A3 A4
const int TrackSensorLeftPin1 = 4; //定义左边第一个循迹红外传感器引脚为A2
const int TrackSensorLeftPin2 = 5; //定义左边第二个循迹红外传感器引脚为A1
const int TrackSensorRightPin1 = 3; //定义右边第一个循迹红外传感器引脚为A3
const int TrackSensorRightPin2 = 2; //定义右边第二个循迹红外传感器引脚为A4
//定义各个循迹红外引脚采集的数据的变量
bool TrackSensorLeftValue1;
bool TrackSensorLeftValue2;
bool TrackSensorRightValue1;
bool TrackSensorRightValue2;
String infrared_track_value = ""0000"";
/*避障红外传感器引脚及变量设置*/
const int AvoidSensorLeft = 9; //定义左边避障的红外传感器引脚为A3
const int AvoidSensorRight = 8; //定义右边避障的红外传感器引脚为A1
const int FollowSensorLeft = 9; //定义左边跟随的红外传感器引脚为A3
const int FollowSensorRight = 8; //定义右边跟随的红外传感器引脚为A1
int LeftSensorValue; //定义变量来保存红外传感器采集的数据大小
int RightSensorValue;
String infrared_avoid_value = ""00"";
/*定义光敏电阻引脚及变量设置*/
const int LdrSensorLeft = A1; //定义左边光敏电阻引脚为A4
const int LdrSensorRight = A3; //定义右边光敏电阻引脚为A2
int LdrSersorLeftValue; //定义变量来保存光敏电阻采集的数据大小
int LdrSersorRightValue;
String LDR_value = ""00"";
double position = 0; //七彩探照
/*电压引脚及其变量设置*/
const int VoltagePin = A2;
double VoltageValue = 0;
/*小车初始速度控制*/
int CarSpeedControl = 150;
/*超声波引脚及变量设置*/
const int EchoPin = 13; //Echo回声脚
const int TrigPin = 12; //Trig触发脚
float distance = 0;
/*颜色值*/
int red, green, blue;
/*计时变量用于延时*/
int time = 20000;
int count = 10;
/*串口数据设置*/
int IncomingByte = 0; //接收到的 data byte
String InputString = """"; //用来储存接收到的内容
boolean NewLineReceived = false; //前一次数据结束标志
boolean StartBit = false; //协议开始标志
String ReturnTemp = """"; //存储返回值
/*状态机状态*/
int g_CarState = enSTOP; //1前2后3左4右0停止
int g_modeSelect = 0; //0是默认状态; 1:红外遥控 2:巡线模式 3:超声波避障 4: 七彩探照 5: 寻光模式 6: 红外跟踪
boolean g_motor = false;
/*printf格式化字符串初始化*/
int serial_putc(char c, struct __file *)
{
Serial.write(c);
return c;
}
void printf_begin(void)
{
fdevopen(&serial_putc, 0);
}
/**
* Function setup
* @author wusicaijuan
* @date 2019.07.01
* @brief 初始化配置
* @param[in] void
* @retval void
* @par History 无
*/
void setup()
{
//串口波特率设置
Serial.begin(9600);
printf_begin();
strip.begin();
strip.show();
PCB_RGB_OFF();
//初始化电机驱动IO为输出方式
pwm.begin();
pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates
Clear_All_PWM();
Servo180(7, 90);
// PCB_LED();
breathing_light(255, 40, 5);
pinMode(VoltagePin, INPUT);
pinMode(buzzer, OUTPUT); //设置数字IO脚模式，OUTPUT为输出
digitalWrite(buzzer, HIGH); // 持续给触发脚低电
//定义四路循迹红外传感器为输入接口
pinMode(TrackSensorLeftPin1, INPUT);
pinMode(TrackSensorLeftPin2, INPUT);
pinMode(TrackSensorRightPin1, INPUT);
pinMode(TrackSensorRightPin2, INPUT);
//定义红外寻光管脚为输入模式
pinMode(AvoidSensorLeft, INPUT);
pinMode(AvoidSensorRight, INPUT);
pinMode(FollowSensorLeft, INPUT);
pinMode(FollowSensorRight, INPUT);
pinMode(LdrSensorLeft, INPUT);
pinMode(LdrSensorRight, INPUT);
pinMode(key, INPUT); //定义按键输入脚
//初始化超声波引脚模式
pinMode(EchoPin, INPUT); //定义超声波输入脚
pinMode(TrigPin, OUTPUT); //定义超声波输出脚
}
/**
* Function Distance_test
* @author Danny
* @date 2017.07.26
* @brief 超声波测距
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void Distance_test()
{
digitalWrite(TrigPin, LOW); //给触发脚低电平2μs
delayMicroseconds(2);
digitalWrite(TrigPin, HIGH); //给触发脚高电平10μs，这里至少是10μs
delayMicroseconds(10);
digitalWrite(TrigPin, LOW);
float Fdistance = pulseIn(EchoPin, HIGH); // 读取高电平时间(单位：微秒)
Fdistance = Fdistance / 58;
// Serial.print(""Distance:""); //输出距离（单位：厘米）
// Serial.print(Fdistance); //显示距离
// Serial.println(""cm"");
distance = Fdistance;
// return;
}
/**
* Function voltage_test
* @author wusicaijuan
* @date 2019.07.04
* @brief 电池电压引脚检测
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
float voltage_test()
{
VoltageValue = analogRead(VoltagePin); //读取A0口值,换算为电压值
//方法一:通过电路原理图和采集的A0口模拟值得到电压值
// Serial.println(VoltageValue);
VoltageValue = (VoltageValue / 1023) * 5.02 * 4.03;
return VoltageValue;
//Voltage是端口A0采集到的ad值（0-1023），
//1.75是（R14+R15）/R15的结果，其中R14=15K,R15=20K）。
return 0;
}
/**
* Function track_test
* @author Danny
* @date 2017.07.26
* @brief 循迹模式引脚测试
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
//循迹和红外避障,寻光模块复用了A1,A2,A3,A4
//采集红外避障和寻光时要禁用循迹数据的采集
void track_test()
{
//检测到黑线时循迹模块相应的指示灯亮，端口电平为LOW
//未检测到黑线时循迹模块相应的指示灯灭，端口电平为HIGH
TrackSensorLeftValue1 = digitalRead(TrackSensorLeftPin1);
TrackSensorLeftValue2 = digitalRead(TrackSensorLeftPin2);
TrackSensorRightValue1 = digitalRead(TrackSensorRightPin1);
TrackSensorRightValue2 = digitalRead(TrackSensorRightPin2);
(TrackSensorLeftValue1 == LOW) ? infrared_track_value[0] = '1' : infrared_track_value[0] = '0';
(TrackSensorLeftValue2 == LOW) ? infrared_track_value[1] = '1' : infrared_track_value[1] = '0';
(TrackSensorRightValue1 == LOW) ? infrared_track_value[2] = '1' : infrared_track_value[2] = '0';
(TrackSensorRightValue2 == LOW) ? infrared_track_value[3] = '1' : infrared_track_value[3] = '0';
//infrared_track_value = ""0000"";
return;
}
/**
* Function track_get_value
* @author liusen
* @date 2017.07.26
* @brief 循迹模式引脚测试
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void track_get_value()
{
TrackSensorLeftValue1 = digitalRead(TrackSensorLeftPin1);
TrackSensorLeftValue2 = digitalRead(TrackSensorLeftPin2);
TrackSensorRightValue1 = digitalRead(TrackSensorRightPin1);
TrackSensorRightValue2 = digitalRead(TrackSensorRightPin2);
}
/**
* Function infrared_avoid_test
* @author Danny
* @date 2017.07.26
* @brief 避障红外引脚测试
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void infrared_avoid_test()
{
//遇到障碍物,红外避障模块的指示灯亮,端口电平为LOW
//未遇到障碍物,红外避障模块的指示灯灭,端口电平为HIGH
LeftSensorValue = digitalRead(AvoidSensorLeft);
RightSensorValue = digitalRead(AvoidSensorRight);
(LeftSensorValue == LOW) ? infrared_avoid_value[0] = '1' : infrared_avoid_value[0] = '0';
(RightSensorValue == LOW) ? infrared_avoid_value[1] = '1' : infrared_avoid_value[1] = '0';
return;
}
/**
* Function follow_light_test
* @author Danny
* @date 2017.07.26
* @brief 寻光引脚测试
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void follow_light_test()
{
//遇到光线,寻光模块的指示灯灭,端口电平为HIGH
//未遇光线,寻光模块的指示灯亮,端口电平为LOW
LdrSersorRightValue = digitalRead(LdrSensorRight);
LdrSersorLeftValue = digitalRead(LdrSensorLeft);
(LdrSersorLeftValue == LOW) ? LDR_value[0] = '0' : LDR_value[0] = '1';
(LdrSersorRightValue == LOW) ? LDR_value[1] = '0' : LDR_value[1] = '1';
return;
}
/**
* Function run
* @author wusicaijuan
* @date 2019.06.25
* @brief 小车前进
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void run(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, Speed); //右前
pwm.setPWM(11, 0, 0);
pwm.setPWM(8, 0, Speed); //右后
pwm.setPWM(9, 0, 0);
pwm.setPWM(13, 0, Speed); //左前
pwm.setPWM(12, 0, 0);
pwm.setPWM(15, 0, Speed); //左后
pwm.setPWM(14, 0, 0);
}
/**
* Function back
* @author wusicaijuan
* @date 2019.06.25
* @brief 小车后退
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void back(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, 0);
pwm.setPWM(11, 0, Speed);
pwm.setPWM(8, 0, 0);
pwm.setPWM(9, 0, Speed);
pwm.setPWM(13, 0, 0);
pwm.setPWM(12, 0, Speed);
pwm.setPWM(15, 0, 0);
pwm.setPWM(14, 0, Speed);
}
/**
* Function brake
* @author wusicaijuan
* @date 2019.06.25
* @brief 小车刹车
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void brake()
{
pwm.setPWM(8, 0, 0);
pwm.setPWM(9, 0, 0);
pwm.setPWM(11, 0, 0);
pwm.setPWM(10, 0, 0);
pwm.setPWM(12, 0, 0);
pwm.setPWM(13, 0, 0);
pwm.setPWM(14, 0, 0);
pwm.setPWM(15, 0, 0);
}
/**
* Function left
* @author wusicaijuan
* @date 2019.06.26
* @brief 小车左转(左轮不动，右轮前进)
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void left(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, Speed);
pwm.setPWM(11, 0, 0);
pwm.setPWM(8, 0, 0);
pwm.setPWM(9, 0, Speed);
pwm.setPWM(13, 0, 0);
pwm.setPWM(12, 0, Speed);
pwm.setPWM(15, 0, Speed);
pwm.setPWM(14, 0, 0);
}
/**
* Function right
* @author wusicaijuan
* @date 2019.06.26
* @brief 小车右转(右轮不动，左轮前进)
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void right(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, 0);
pwm.setPWM(11, 0, Speed);
pwm.setPWM(8, 0, Speed);
pwm.setPWM(9, 0, 0);
pwm.setPWM(13, 0, Speed);
pwm.setPWM(12, 0, 0);
pwm.setPWM(15, 0, 0);
pwm.setPWM(14, 0, Speed);
}
/**
* Function spin_left
* @author wusicaijuan
* @date 2019.06.25
* @brief 小车原地左转(左轮后退，右轮前进)
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void spin_left(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, Speed);
pwm.setPWM(11, 0, 0);
pwm.setPWM(8, 0, Speed);
pwm.setPWM(9, 0, 0);
pwm.setPWM(13, 0, 0);
pwm.setPWM(12, 0, Speed);
pwm.setPWM(15, 0, 0);
pwm.setPWM(14, 0, Speed);
}
/**
* Function spin_right
* @author wusicaijuan
* @date 2019.06.25
* @brief 小车原地右转(右轮后退，左轮前进)
* @param[in] Speed
* @param[out] void
* @retval void
* @par History 无
*/
void spin_right(int Speed)
{
Speed = map(Speed, 0, 255, 0, 4095);
pwm.setPWM(10, 0, 0);
pwm.setPWM(11, 0, Speed);
pwm.setPWM(8, 0, 0);
pwm.setPWM(9, 0, Speed);
pwm.setPWM(13, 0, Speed);
pwm.setPWM(12, 0, 0);
pwm.setPWM(15, 0, Speed);
pwm.setPWM(14, 0, 0);
}
/*
* Function Servo180(num, degree)
* @author wusicaijuan
* @date 2019.06.25
* @bried 180°舵机转动角度
180 Degree Steering Engine Rotation Angle
* @param[in1] index
1: s1
2: s2
3: s3
4: s4
* @param[in2] degree (0 <= degree <= 180)
* @retval void
*/
void Servo180(int num, int degree)
{
long us = (degree * 1800 / 180 + 600); // 0.6 ~ 2.4
long pwmvalue = us * 4096 / 20000; // 50hz: 20,000 us
pwm.setPWM(enServo[num - 1], 0, pwmvalue);
}
/*
* Function Servo270(num, degree)
* @author wusicaijuan
* @date 2019.06.25
* @bried 270°舵机转动角度
270 Degree Steering Engine Rotation Angle
* @param[in1] index
1: s1
2: s2
3: s3
4: s4
* @param[in2] degree (0 <= degree <= 270)
* @retval void
*/
void Servo270(int num, int degree)
{
degree = map(degree, 0, 255, 0, 4095);
long us = (degree * 1800 / 180 + 600); // 0.6 ~ 2.4
long pwmvalue = us * 4096 / 20000; // 50hz: 20,000 us
pwm.setPWM(enServo[num - 1], 0, pwmvalue);
}
// you can use this function if you'd like to set the pulse length in seconds
// e.g. setServoPulse(0, 0.001) is a ~1 millisecond pulse width. its not precise!
void setServoPulse(int num, double pulse)
{
double pulselength;
pulselength = 1000000; // 1,000,000 us per second
pulselength /= 60; // 60 Hz
pulselength /= 4096; // 12 bits of resolution
pulse *= 1000;
pulse /= pulselength;
pwm.setPWM(enServo[num - 1], 0, pulse);
}
/**
* Function setRGB(R,G,B)
* @author wusicaijuan
* @date 2019.06.26
* @brief 设置外接RGB灯
* @param[in1] R
* @param[in2] G
* @param[in3] B
* @param[out] void
* @retval void
* @par History 无
*/
void setRGB(int R, int G, int B)
{
R = map(R, 0, 255, 0, 4095);
G = map(G, 0, 255, 0, 4095);
B = map(B, 0, 255, 0, 4095);
pwm.setPWM(6, 0, R);
pwm.setPWM(5, 0, G);
pwm.setPWM(4, 0, B);
}
/**
* Function PCB_RGB(R,G,B)
* @author wusicaijuan
* @date 2019.06.26
* @brief 设置板载RGB灯
* @param[in1] R
* @param[in2] G
* @param[in3] B
* @param[out] void
* @retval void
* @par History 无
*/
void PCB_RGB(int R, int G, int B)
{
uint8_t i = 0;
R = map(R, 0, 255, 0, 10);
G = map(G, 0, 255, 0, 10);
B = map(B, 0, 255, 0, 10);
uint32_t color = strip.Color(G, R, B);
strip.setPixelColor(i, color);
strip.show();
}
/**
* Function PCB_RGB(R,G,B)
* @author wusicaijuan
* @date 2019.06.26
* @brief 设置板载RGB灯
* @param[in1] void
* @param[out] void
* @retval void
* @par History 无
*/
void PCB_RGB_OFF()
{
uint32_t color = strip.Color(0, 0, 0);
for(uint8_t i = 0;i<4;i++){
strip.setPixelColor(i, color);
}
strip.show();
}
/**
* Function PCB_LED()
* @author wusicaijuan
* @date 2019.07.03
* @brief 设置板载LED灯
* @param[in1] void
* @param[out] void
* @retval void
* @par History 无
*/
void PCB_LED()
{
pwm.setPWM(7, 0, 4095);
}
/**
* Function breathing_light(brightness,time,increament)
* @author wusicaijuan
* @date 2019.06.26
* @brief 呼吸灯
* @param[in1] brightness
* @param[in2] time
* @param[in3] increament
* @param[out] void
* @retval void
* @par History 无
*/
void breathing_light(int brightness, int time, int increament)
{
if (brightness < 0)
{
brightness = 0;
}
if (brightness > 255)
{
brightness = 255;
}
for (int b = 0; b < brightness; b += increament)
{
int newb = map(b, 0, 255, 0, 4095);
pwm.setPWM(7, 0, newb);
delay(time);
}
}
/********************************************************************************************************/
/*模式2 巡线*/
/**
* Function Tracking_Mode
* @author Danny
* @date 2017.07.25
* @brief 巡线
* @param[in1] void
* @param[out] void
* @retval void
* @par History 无
*/
void Tracking_Mode()
{
//检测到黑线时循迹模块相应的指示灯亮，端口电平为LOW
//未检测到黑线时循迹模块相应的指示灯灭，端口电平为HIGH
TrackSensorLeftValue1 = digitalRead(TrackSensorLeftPin1);
TrackSensorLeftValue2 = digitalRead(TrackSensorLeftPin2);
TrackSensorRightValue1 = digitalRead(TrackSensorRightPin1);
TrackSensorRightValue2 = digitalRead(TrackSensorRightPin2);
//在巡线过程中发送巡线传感器效果
time--;
if (time == 0)
{
count--;
time = 2000;
if (count == 0)
{
printf(""$4WD,CSB0,PV8,GS0,LF%d%d%d%d,HW00,GM00#"", !TrackSensorLeftValue1, !TrackSensorLeftValue2, !TrackSensorRightValue1, !TrackSensorRightValue2);
time = 2000;
count = 1;
}
}
//四路循迹引脚电平状态
// 0 0 X 0
// 1 0 X 0
// 0 1 X 0
//以上6种电平状态时小车原地右转，速度为250,延时80ms
//处理右锐角和右直角的转动
if ((TrackSensorLeftValue1 == LOW || TrackSensorLeftValue2 == LOW) && TrackSensorRightValue2 == LOW)
{
spin_right(80);
delay(80);
}
//四路循迹引脚电平状态
// 0 X 0 0
// 0 X 0 1
// 0 X 1 0
//处理左锐角和左直角的转动
else if (TrackSensorLeftValue1 == LOW && (TrackSensorRightValue1 == LOW || TrackSensorRightValue2 == LOW))
{
spin_left(80);
delay(80);
}
// 0 X X X
//最左边检测到
else if (TrackSensorLeftValue1 == LOW)
{
spin_left(80);
//delay(10);
}
// X X X 0
//最右边检测到
else if (TrackSensorRightValue2 == LOW)
{
spin_right(80);
//delay(10);
}
//四路循迹引脚电平状态
// X 0 1 X
//处理左小弯
else if (TrackSensorLeftValue2 == LOW && TrackSensorRightValue1 == HIGH)
{
left(80);
}
//四路循迹引脚电平状态
// X 1 0 X
//处理右小弯
else if (TrackSensorLeftValue2 == HIGH && TrackSensorRightValue1 == LOW)
{
right(80);
}
//四路循迹引脚电平状态
// X 0 0 X
//处理直线
else if (TrackSensorLeftValue2 == LOW && TrackSensorRightValue1 == LOW)
{
run(60);
}
}
/********************************************************************************************************/
/*模式3:超声波避障模式*/
/**
* Function servo_color_carstate
* @author Danny
* @date 2017.07.26
* @brief 舵机转向超声波测距避障行驶,led根据车的状态显示相应的颜色
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void servo_color_carstate()
{
//定义舵机位置变量和小车前方,左侧,右侧距离
int LeftDistance = 0; //左方距离值变量LeftDistance
int RightDistance = 0; //右方距离值变量RightDistance
int FrontDistance = 0; //前方距离值变量FrontDistance
setRGB(255, 0, 0);
// back(150); //避免突然停止,刹不住车
// delay(80);
brake();
//舵机旋转到0度,即右侧,测距
Servo180(1, 0);
delay(500);
Distance(); //测距
RightDistance = distance; //所测的右侧距离赋给变量RightDistance
//舵机旋转到180度,即左侧,测距
Servo180(1, 180);
delay(500);
Distance(); //测距
LeftDistance = distance; //所测的左侧距离赋给变量LeftDistance
//舵机旋转到90度,即左侧,测距
Servo180(1, 90);
delay(500);
Distance();
FrontDistance = distance; //所测前侧距离付给变量FrontDistance
if (LeftDistance < 10 && RightDistance < 10 && FrontDistance < 10)
{
//亮品红色,掉头
setRGB(255, 0, 0);
spin_right(80);
delay(500);
brake();
}
else if (LeftDistance >= RightDistance) //当发现左侧距离大于右侧，原地左转
{
//亮蓝色
setRGB(0, 0, 255);
spin_left(80);
delay(300);
brake();
}
else if (LeftDistance < RightDistance) //当发现右侧距离大于左侧，原地右转
{
//亮品红色,向右转
setRGB(255, 0, 0);
spin_right(80);
delay(300);
brake();
}
}
/**
* Function bubble
* @author Danny
* @date 2017.07.26
* @brief 超声波测五次的数据进行冒泡排序
* @param[in1] a:超声波数组首地址
* @param[in2] n:超声波数组大小
* @param[out] void
* @retval void
* @par History 无
*/
void bubble(unsigned long *a, int n)
{
int i, j, temp;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
if (a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
}
/**
* Function Distance
* @author Danny
* @date 2017.07.26
* @brief 超声波测五次，去掉最大值,最小值,
* 取平均值,提高测试准确性
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void Distance()
{
unsigned long ultrasonic[5] = {0};
int num = 0;
while (num < 5)
{
Distance_test();
//过滤掉测试距离中出现的错误数据大于500,或者distance==0
while (distance >= 600 || distance == 0)
{
brake();
Distance_test();
}
ultrasonic[num] = distance;
// printf(""L%d:%d\\r\\n"", num, (int)distance);
num++;
delay(10);
}
num = 0;
bubble(ultrasonic, 5);
distance = (ultrasonic[1] + ultrasonic[2] + ultrasonic[3]) / 3;
return;
}
/**
* Function Ultrasonic_avoidMode
* @author Danny
* @date 2017.07.26
* @brief 超声波避障模式
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void Ultrasonic_avoidMode()
{
Distance(); //测量前方距离
// printf(""D:%d\\r\\n"", (int)distance);
if (distance > 20) //障碍物距离大于50时，开启左右红外辅助避障
{
//遇到障碍物,红外避障模块的指示灯亮,端口电平为LOW
//未遇到障碍物,红外避障模块的指示灯灭,端口电平为HIGH
LeftSensorValue = digitalRead(AvoidSensorLeft);
RightSensorValue = digitalRead(AvoidSensorRight);
if (LeftSensorValue == HIGH && RightSensorValue == LOW)
{
spin_left(80); //右边探测到有障碍物，有信号返回，原地向左转
delay(200);
}
else if (RightSensorValue == HIGH && LeftSensorValue == LOW)
{
spin_right(80); //左边探测到有障碍物，有信号返回，原地向右转
delay(200);
}
else if (RightSensorValue == LOW && LeftSensorValue == LOW)
{
spin_right(80); //当两侧均检测到障碍物时调用固定方向的避障(原地右转)
delay(200);
}
run(60);
setRGB(0, 255, 0);
}
else if (distance <= 20) //当距离小于30时调用舵机颜色控制程序
{
servo_color_carstate();
}
}
/********************************************************************************************************/
/*模式:4 七彩颜色*/
void FindColor_Mode()
{
for (position = 0; position < 180; position += 10)
{
Servo180(1, position);
setRGB(random(0, 255), random(0, 255), random(0, 255));
delay(100);
}
for (position = 180; position > 0; position -= 10)
{
Servo180(1, position);
setRGB(random(0, 255), random(0, 255), random(0, 255));
delay(100);
}
}
/********************************************************************************************************/
/*模式5: 寻光模式*/
void LightSeeking_Mode()
{
//遇到光线,寻光模块的指示灯灭,端口电平为HIGH
//未遇光线,寻光模块的指示灯亮,端口电平为LOW
LdrSersorRightValue = digitalRead(LdrSensorRight);
LdrSersorLeftValue = digitalRead(LdrSensorLeft);
if (LdrSersorLeftValue == HIGH && LdrSersorRightValue == HIGH)
{
run(60); //两侧均有光时信号为HIGH，光敏电阻指示灯灭,小车前进
}
else if (LdrSersorLeftValue == HIGH && LdrSersorRightValue == LOW)
{
left(60); //左边探测到有光，有信号返回，向左转
}
else if (LdrSersorRightValue == HIGH && LdrSersorLeftValue == LOW)
{
right(60); //右边探测到有光，有信号返回，向右转
}
else
{
brake(); //均无光，停止
}
time--;
if (time == 0)
{
count--;
time = 2000;
if (count == 0)
{
printf(""$4WD,CSB120,PV8.3,GS000,LF0000,HW00,GM%d%d#"", LdrSersorLeftValue, LdrSersorRightValue);
time = 2000;
count = 1;
}
}
}
/********************************************************************************************************/
/*模式6: 红外跟随模式*/
void Ir_flow_Mode()
{
//遇到跟随物,红外跟随模块的指示灯亮,端口电平为LOW
//未遇到跟随物,红外跟随模块的指示灯灭,端口电平为HIGH
LeftSensorValue = digitalRead(FollowSensorLeft);
RightSensorValue = digitalRead(FollowSensorRight);
if (LeftSensorValue == LOW && RightSensorValue == LOW)
{
run(60); //当两侧均检测到跟随物时调用前进函数
}
else if (LeftSensorValue == LOW && RightSensorValue == HIGH)
{
spin_left(80); //左边探测到有跟随物，有信号返回，原地向左转
}
else if (RightSensorValue == LOW && LeftSensorValue == HIGH)
{
spin_right(80); //右边探测到有跟随物，有信号返回，原地向右转
}
else
{
brake(); //当两侧均未检测到跟随物时停止
}
time--;
if (time == 0)
{
count--;
time = 2000;
if (count == 0)
{
printf(""$4WD,CSB120,PV8.3,GS000,LF0000,HW%d%d,GM00"", LeftSensorValue, RightSensorValue);
time = 2000;
count = 1;
}
}
}
/**
* Function serial_data_parse
* @author Danny
* @date 2017.07.25
* @brief 串口数据解析并指定相应的动作
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void serial_data_parse()
{
/*解析模式切换*/
//先判断是否是模式选择
if (InputString.indexOf(""MODE"") > 0 && InputString.indexOf(""4WD"") > 0)
{
if (InputString[10] == '0') //停止模式
{
brake();
g_CarState = enSTOP;
g_modeSelect = 0;
//position = 0;
}
else
{
switch (InputString[9])
{
case '0':
g_modeSelect = 0;
break;
case '1':
g_modeSelect = 1;
break;
case '2':
g_modeSelect = 2;
break;
case '3':
g_modeSelect = 3;
break;
case '4':
g_modeSelect = 4;
break;
case '5':
g_modeSelect = 5;
break;
case '6':
g_modeSelect = 6;
break;
default:
g_modeSelect = 0;
break;
}
delay(1000);
}
InputString = """"; //清空串口数据
NewLineReceived = false;
return;
}
//非apk模式则退出
if (g_modeSelect != 0) //
{
InputString = """"; //清空串口数据
NewLineReceived = false;
return;
}
//解析上位机发来的舵机云台的控制指令并执行舵机旋转
//如:$4WD,PTZ180# 舵机转动到180度
if (InputString.indexOf(""PTZ"") > 0)
{
int i = InputString.indexOf(""PTZ""); //寻找以PTZ开头,#结束中间的字符
int ii = InputString.indexOf(""#"", i);
if (ii > i)
{
String m_skp = InputString.substring(i + 3, ii);
int m_kp = m_skp.toInt(); //将找到的字符串变成整型
Servo180(1, 180 - m_kp); //转动到指定角度m_kp
InputString = """"; //清空串口数据
NewLineReceived = false;
return;
}
}
//解析上位机发来的七彩探照灯指令并点亮相应的颜色
//如:$4WD,CLR255,CLG0,CLB0# 七彩灯亮红色
else if (InputString.indexOf(""CLR"") > 0)
{
int i = InputString.indexOf(""CLR"");
int ii = InputString.indexOf("","", i);
if (ii > i)
{
String m_skp = InputString.substring(i + 3, ii);
int m_kp = m_skp.toInt();
// Serial.print(""CLR:"");
// Serial.println(m_kp);
red = m_kp;
}
i = InputString.indexOf(""CLG"");
ii = InputString.indexOf("","", i);
if (ii > i)
{
String m_skp = InputString.substring(i + 3, ii);
int m_kp = m_skp.toInt();
// Serial.print(""CLG:"");
// Serial.println(m_kp);
green = m_kp;
}
i = InputString.indexOf(""CLB"");
ii = InputString.indexOf(""#"", i);
if (ii > i)
{
String m_skp = InputString.substring(i + 3, ii);
int m_kp = m_skp.toInt();
// Serial.print(""CLB:"");
// Serial.println(m_kp);
blue = m_kp;
setRGB(red, green, blue); //点亮相应颜色的灯
InputString = """"; //清空串口数据
NewLineReceived = false;
return;
}
}
//解析上位机发来的通用协议指令,并执行相应的动作
//如:$1,0,0,0,0,0,0,0,0,0# 小车前进
if (InputString.indexOf(""4WD"") == -1)
{
//小车原地左旋右旋判断
if (InputString[3] == '1') //小车原地左旋
{
g_CarState = enTLEFT;
}
else if (InputString[3] == '2') //小车原地右旋
{
g_CarState = enTRIGHT;
}
else
{
g_CarState = enSTOP;
}
//小车鸣笛判断
if (InputString[5] == '1') //鸣笛
{
}
//小车加减速判断
if (InputString[7] == '1') //加速，每次加50
{
CarSpeedControl += 50;
if (CarSpeedControl > 255)
{
CarSpeedControl = 255;
}
}
if (InputString[7] == '2') //减速，每次减50
{
CarSpeedControl -= 50;
if (CarSpeedControl < 50)
{
CarSpeedControl = 100;
}
}
//舵机左旋右旋判断
if (InputString[9] == '1') //舵机旋转到180度
{
Servo180(1, 180);
}
if (InputString[9] == '2') //舵机旋转到0度
{
Servo180(1, 0);
}
//点灯判断
switch (InputString[13])
{
case '1':
setRGB(255, 255, 255);
break;
case '2':
setRGB(255, 0, 0);
break;
case '3':
setRGB(0, 255, 0);
break;
case '4':
setRGB(0, 0, 255);
break;
case '5':
setRGB(0, 255, 255);
break;
case '6':
setRGB(255, 0, 255);
break;
case '7':
setRGB(255, 255, 0);
break;
case '8':
setRGB(0, 0, 0);
break;
}
//舵机归为判断
if (InputString[17] == '1') //舵机旋转到90度
{
Servo180(1, 90);
}
//小车的前进,后退,左转,右转,停止动作
if (g_CarState != enTLEFT && g_CarState != enTRIGHT)
{
switch (InputString[1])
{
case run_car:
g_CarState = enRUN;
break;
case back_car:
g_CarState = enBACK;
break;
case left_car:
g_CarState = enLEFT;
break;
case right_car:
g_CarState = enRIGHT;
break;
case stop_car:
g_CarState = enSTOP;
break;
default:
g_CarState = enSTOP;
break;
}
}
InputString = """"; //清空串口数据
NewLineReceived = false;
//根据小车状态做相应的动作
switch (g_CarState)
{
case enSTOP:
brake();
break;
case enRUN:
run(CarSpeedControl);
break;
case enLEFT:
left(CarSpeedControl);
break;
case enRIGHT:
right(CarSpeedControl);
break;
case enBACK:
back(CarSpeedControl);
break;
case enTLEFT:
spin_left(CarSpeedControl);
break;
case enTRIGHT:
spin_right(CarSpeedControl);
break;
default:
brake();
break;
}
}
}
/**
* Function serialEvent
* @author Danny
* @date 2017.07.25
* @brief 串口解包
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void serialEvent()
{
while (Serial.available())
{
//一个字节一个字节地读,下一句是读到的放入字符串数组中组成一个完成的数据包
IncomingByte = Serial.read();
if (IncomingByte == '$')
{
StartBit = true;
}
if (StartBit == true)
{
InputString += (char)IncomingByte;
}
if (IncomingByte == '#')
{
NewLineReceived = true;
StartBit = false;
}
}
}
/**
* Function loop
* @author wusicaijuan
* @date 2019.07.05
* @brief 对串口发送过来的数据解析，并执行相应的指令
* @param[in] void
* @retval void
* @par History 无
*/
void loop()
{
serialEvent();
if (NewLineReceived)
{
serial_data_parse(); //调用串口解析函数
}
// 切换不同功能模式, 功能模式显示
switch (g_modeSelect)
{
case 1:
break; //暂时保留
case 2:
// Tracking_Mode();
break; //巡线模式
case 3:
// Ultrasonic_avoidMode();
break; //超声波避障模式
case 4:
// FindColor_Mode();
break; //七彩颜色识别模式
case 5:
// LightSeeking_Mode();
break; //寻光模式
case 6:
// Ir_flow_Mode();
break; //跟随模式
}
}
/**
* Function keysacn
* @author wusicaijuan
* @date 2019.06.04
* @brief 按键扫描
* @param[in1] void
* @retval void
* @par History 无
*/
void keysacn()
{
int val;
val = digitalRead(key); //读取数字7口电平值赋给val
while (val == HIGH) //当按键没被按下时，一直循环
{
val = digitalRead(key); //此句可省略，可让循环跑空
}
while (val == LOW) //当按键被按下时
{
delay(1); //延时10ms
val = digitalRead(key); //读取数字7口电平值赋给val
while (val == HIGH) //判断按键是否被松开
{
break;
}
}
}
/*
* Function Controling
* @author wusicaijuan
* @date 2019.07.04
* @brief 控制模式
* @param[in] void
* @param[out] void
* @retval void
* @par History 无
*/
void Clear_All_PWM()
{
for (int i = 0; i < 16; i++)
{
pwm.setPWM(i, 0, 0);
}
}
/**
* Function whistle
* @author wusicaijuan
* @date 2019.07.09
* @brief 鸣笛
* @param[in1] void
* @retval void
* @par History 无
*/
void whistle() //鸣笛
{
for (int i = 0; i < 50; i++)
{
digitalWrite(buzzer, HIGH); //发声音
delay(3); //延时
digitalWrite(buzzer, LOW); //不发声音
delay(1); //延时
}
}",12048,False,2357.6697550960257,median
"// UTFT_Demo_480x272 (C)2013 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 480x272 pixels.
//
// This program requires the UTFT library.
//
#include
#include // Use Wire according to arcticle https://garretlabs.wordpress.com/2014/03/18/the-dark-side-of-porting-arduino-sketches-on-intel-galileo-part-one/
#include
#include ""BigNumber.h"" // https://github.com/nickgammon/BigNumber by Nick Gammon
// Declare which fonts we will be using
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
UTFT myGLCD(SSD1963_480, 38, 39, 40, 41); // Remember to change the model parameter to suit your display module!
double TimeBaseFrequencyHz = (double)16384000.0;
void setup()
{
// Setup the LCD
myGLCD.InitLCD();
// reset pin is high by default
pinMode(9, OUTPUT);
analogWrite(9, 255);
// Frequency mux pins
pinMode(11, OUTPUT); // PB5 Digital 11 Mux A
pinMode(12, OUTPUT); // PB6 Digital 12 Mux B
pinMode(13, OUTPUT); // PB7 Digital 13 Mux C
selectDiv1Frequency();
// relays
pinMode(44, OUTPUT); // PL5 relay reset HIGH=Energized
pinMode(45, OUTPUT); // PL4 range 4 HIGH=Energized
pinMode(46, OUTPUT); // PL3 range 3 HIGH=Energized
pinMode(47, OUTPUT); // PL2 range 2 HIGH=Energized
pinMode(48, OUTPUT); // PL1 range 1 HIGH=Energized
digitalWrite(44, LOW);
digitalWrite(45, LOW);
digitalWrite(46, LOW);
digitalWrite(47, LOW);
digitalWrite(48, LOW);
// channell switch
pinMode(49, OUTPUT); // PL0 channel switch. LOW=V, HIGH=I
digitalWrite(49, HIGH); // switch. LOW=V, HIGH=I
// unused serial pins
pinMode(50, OUTPUT); // PB3 MISO
pinMode(51, OUTPUT); // PB2 MOSI
pinMode(52, OUTPUT); // PB1 SCK
pinMode(53, OUTPUT); // PB0 not connected
// Gain pins
pinMode(16, OUTPUT); // PH1 LO G0 Digital 16
pinMode(17, OUTPUT); // PH0 LO G1 Digital 17
pinMode(18, OUTPUT); // PD3 LO G2 Digital 18
pinMode(19, OUTPUT); // PD2 LO G3 Digital 19
pinMode(A15, OUTPUT); // PK7 LO G4 Analog 15
pinMode(A14, OUTPUT); // PK6 HI G0 Analog 14
pinMode(A13, OUTPUT); // PK5 HI G1 Analog 13
pinMode(A12, OUTPUT); // PK4 HI G2 Analog 12
pinMode(A11, OUTPUT); // PK3 HI G3 Analog 11
pinMode(A10, OUTPUT); // PK2 HI G4 Analog 10
// set LO G3..0=0011, G4=0 to set gain 1:1 // High Gain -> greater phase lag ?
// set LO G3..0=0100, G4=0 to set gain 1:2
// set LO G3..0=0101, G4=0 to set gain 1:4
// set LO G3..0=0110, G4=0 to set gain 1:8
// set LO G3..0=0111, G4=0 to set gain 1:16
// set LO G3..0=1000, G4=0 to set gain 1:32
// set LO G3..0=1001, G4=0 to set gain 1:64
// set LO G3..0=1010, G4=0 to set gain 1:128
digitalWrite(16, HIGH);
digitalWrite(17, LOW);
digitalWrite(18, LOW);
digitalWrite(19, HIGH);
analogWrite(A15, 0);
// set HI G3..0=0000, G4=0 to set gain 1:0.125
// set HI G3..0=0001, G4=0 to set gain 1:0.25
// set HI G3..0=0011, G4=0 to set gain 1:1
// set HI G3..0=0100, G4=0 to set gain 1:2
// set HI G3..0=0101, G4=0 to set gain 1:4
// set HI G3..0=0110, G4=0 to set gain 1:8
// set HI G3..0=0111, G4=0 to set gain 1:16
// set HI G3..0=1001, G4=0 to set gain 1:64
// set HI G3..0=1010, G4=0 to set gain 1:128
analogWrite(A14, 255);
analogWrite(A13, 0);
analogWrite(A12, 255);
analogWrite(A11, 0);
analogWrite(A10, 0);
Wire.begin();
//select200KOhmRange();
//select10KOhmRange();
//select50ohmRange();
selectOhm24Range();
myGLCD.clrScr();
displayGrid();
}
double totalReI;
double totalImI;
double totalReV;
double totalImV;
double ReferenceOhm = 0;
// Calibration variables
unsigned long totalWait;
int settlingCount = 0;
void loop()
{
BigNumber::begin(40);
BigNumber::setScale(10);
commandAD5933Reset(); // reset command
displayTemperature();
commandAD5933ExternalClock(); // external clock
commandAD5933GainX1();
commandAD5933Voltage3V();
//commandAD5933Voltage1500mV();
//commandAD5933Voltage600mV();
//commandAD5933Voltage300mV();
writeAD5933FrequencyHz((double)10000.0);
//writeAD5933FrequencyHz((double)492.25*64);
//writeAD5933FrequencyHz((double)500.0*64);
//writeAD5933FrequencyHz((double)30000.0);
//writeAD5933FrequencyHz((double)100.0);
writeAD5933IncrementHz((double)0);
writeAD5933IncrementsN((word) 0);
writeAD5933SettlingCnt(15);
totalWait = 0;
// I-cycle
totalReI = 0.0;
totalImI = 0.0;
// V-cycle
totalReV = 0.0;
totalImV = 0.0;
commandAD5933Reset(); // reset command
commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
for (byte i = 0; i < 1; i++) {
// V-Cycle. Start V-Cycle as early as possible to let the switching to settle
digitalWrite(49, LOW); // switch. LOW=V, HIGH=I
myGLCD.setFont(SmallFont);
myGLCD.setColor(255, 255, 255);
myGLCD.print(""H"", 461, 1);
do {
} while (analogRead(8) > 128);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 128);
myGLCD.print(""L"", 461, 1);
do {
} while (analogRead(8) <= 128);
//commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
//commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
//commandAD5933StartFrequencySweep();
delay(20);
if (i==0) {
commandAD5933StartFrequencySweep(); }
else {
commandAD5933IncrementFrequency();
}
totalWait += delay2msAD5933UntilReady();
// I-Cycle. Start I-Cycle as early as possible to let the switching to settle
digitalWrite(49, HIGH); // switch. LOW=V, HIGH=I
delay(20);
double VReOnce = readAD5933RealData();
double VImOnce = readAD5933ImaginaryData();
/*
myGLCD.setFont(SmallFont);
myGLCD.setColor(255, 255, 255);
myGLCD.print(""H"", 461, 1);
do {
} while (analogRead(8) > 128);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 128);
myGLCD.print(""L"", 461, 1);
do {
} while (analogRead(8) <= 128);
*/
//commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
//commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
//commandAD5933StartFrequencySweep();
//commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
//commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
//commandAD5933StartFrequencySweep();
commandAD5933RepeatFrequency();
totalWait += delay2msAD5933UntilReady();
double IReOnce = readAD5933RealData();
double IImOnce = readAD5933ImaginaryData();
totalReV = totalReV + VReOnce;
totalImV = totalImV + VImOnce;
totalReI = totalReI + IReOnce;
totalImI = totalImI + IImOnce;
}
//myGLCD.print(""mcs: "", 240, 1); myGLCD.printNumI(totalWait, 317, 1);
// FIXED CALIBRATION VALUES
totalReI = totalReI - 16.0;
totalImI = totalImI - 4.0;
totalReI = totalReI / ((double)1.0 * double(1.0));
totalImI = totalImI / ((double)1.0 * double(1.0));
/*
digitalWrite(49, LOW); // switch. LOW=V, HIGH=I
commandAD5933Reset(); // reset command
commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
for (byte i = 0; i < 6; i++) {
myGLCD.setFont(SmallFont);
myGLCD.setColor(255, 255, 255);
myGLCD.print(""H"", 461, 1);
do {
} while (analogRead(8) > 128);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 128);
myGLCD.print(""L"", 461, 1);
do {
} while (analogRead(8) <= 128);
//commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
//commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
//commandAD5933StartFrequencySweep();
//commandAD5933StanbyMode(); // standby mode command. STANDBY->INITIALIZE->DELAY->SWEEP->INCREMENT is very stable !
//commandAD5933InitializeWithStartFrequency(); // initialize with start frequency
//commandAD5933StartFrequencySweep();
if (i==0) {
commandAD5933StartFrequencySweep(); }
else {
commandAD5933IncrementFrequency();
}
totalWait += delay2msAD5933UntilReady();
double ReOnce = readAD5933RealData();
double ImOnce = readAD5933ImaginaryData();
totalReV = totalReV + ReOnce;
totalImV = totalImV + ImOnce;
}
//myGLCD.print(""mcs: "", 240, 1); myGLCD.printNumI(totalWait, 317, 1);
// FIXED CALIBRATION VALUES
totalReV = totalReV - 16.0;
totalImV = totalImV - 4.0;
*/
// Look at V channel gain setting!
totalReV = totalReV * (double)16.0/(double)1.0; //0.25;
totalImV = totalImV * (double)16.0/(double)1.0; //0.25;
writeAD5933FrequencyHz((double)10000.0);
displayData();
BigNumber::finish();
// walk through all settling counts
settlingCount++;
if (settlingCount > 2044) settlingCount = 0;
}
void selectDiv1Frequency()
{
analogWrite(11, 255); // inverted by level shifting transistor
analogWrite(12, 255); // inverted by level shifting transistor
analogWrite(13, 255); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)16384000.0;
}
void selectDiv2Frequency()
{
analogWrite(11, 0); // inverted by level shifting transistor
analogWrite(12, 255); // inverted by level shifting transistor
analogWrite(13, 255); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)8192000.0;
}
void selectDiv16Frequency()
{
analogWrite(11, 255); // inverted by level shifting transistor
analogWrite(12, 0); // inverted by level shifting transistor
analogWrite(13, 255); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)1024000.0;
}
void selectDiv64Frequency()
{
analogWrite(11, 0); // inverted by level shifting transistor
analogWrite(12, 0); // inverted by level shifting transistor
analogWrite(13, 255); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)256000.0;
}
void selectDiv256Frequency()
{
analogWrite(11, 255); // inverted by level shifting transistor
analogWrite(12, 255); // inverted by level shifting transistor
analogWrite(13, 0); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)64000.0;
}
void selectDiv1024Frequency()
{
analogWrite(11, 0); // inverted by level shifting transistor
analogWrite(12, 255); // inverted by level shifting transistor
analogWrite(13, 0); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)16000.0;
}
void selectDiv4096Frequency()
{
analogWrite(11, 255); // inverted by level shifting transistor
analogWrite(12, 0); // inverted by level shifting transistor
analogWrite(13, 0); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)4000.0;
}
void selectDiv16384Frequency()
{
analogWrite(11, 0); // inverted by level shifting transistor
analogWrite(12, 0); // inverted by level shifting transistor
analogWrite(13, 0); // inverted by level shifting transistor
TimeBaseFrequencyHz = (double)1000.0;
}
void selectOhm24Range()
{
// Deenergize all range relays
digitalWrite(45, LOW); // PL4 range 4 HIGH=Energized
digitalWrite(46, LOW); // PL3 range 3 HIGH=Energized
digitalWrite(47, LOW); // PL2 range 2 HIGH=Energized
digitalWrite(48, LOW); // PL1 range 1 HIGH=Energized
// Energize reset coils
digitalWrite(44, HIGH); // PL5 relay reset HIGH=Energized
delay(2);
digitalWrite(44, LOW); // PL5 relay reset HIGH=Energized
delay(2);
// Energize one range relay
digitalWrite(48, HIGH); // PL1 range 1 HIGH=Energized
delay(2);
digitalWrite(48, LOW); // PL1 range 1 HIGH=Energized
ReferenceOhm = (double)0.24;
ReferenceOhm = (double)0.45610274114131552523016247474564;
ReferenceOhm = (double)0.48460673121136234408836303366844;
}
void select50ohmRange()
{
// Deenergize all range relays
digitalWrite(45, LOW); // PL4 range 4 HIGH=Energized
digitalWrite(46, LOW); // PL3 range 3 HIGH=Energized
digitalWrite(47, LOW); // PL2 range 2 HIGH=Energized
digitalWrite(48, LOW); // PL1 range 1 HIGH=Energized
// Energize reset coils
digitalWrite(44, HIGH); // PL5 relay reset HIGH=Energized
delay(2);
digitalWrite(44, LOW); // PL5 relay reset HIGH=Energized
delay(2);
// Energize one range relay
digitalWrite(47, HIGH); // PL2 range 2 HIGH=Energized
delay(2);
digitalWrite(47, LOW); // PL2 range 2 HIGH=Energized
ReferenceOhm = (double)50.0;
}
void select10KOhmRange()
{
// Deenergize all range relays
digitalWrite(45, LOW); // PL4 range 4 HIGH=Energized
digitalWrite(46, LOW); // PL3 range 3 HIGH=Energized
digitalWrite(47, LOW); // PL2 range 2 HIGH=Energized
digitalWrite(48, LOW); // PL1 range 1 HIGH=Energized
// Energize reset coils
digitalWrite(44, HIGH); // PL5 relay reset HIGH=Energized
delay(2);
digitalWrite(44, LOW); // PL5 relay reset HIGH=Energized
delay(2);
// Energize one range relay
digitalWrite(46, HIGH); // PL3 range 3 HIGH=Energized
delay(2);
digitalWrite(46, LOW); // PL3 range 3 HIGH=Energized
//ReferenceOhm = (double)10333.3333;
ReferenceOhm = (double)10025.531726282725800284844512745;
}
void select200KOhmRange()
{
// Deenergize all range relays
digitalWrite(45, LOW); // PL4 range 4 HIGH=Energized
digitalWrite(46, LOW); // PL3 range 3 HIGH=Energized
digitalWrite(47, LOW); // PL2 range 2 HIGH=Energized
digitalWrite(48, LOW); // PL1 range 1 HIGH=Energized
// Energize reset coils
digitalWrite(44, HIGH); // PL5 relay reset HIGH=Energized
delay(2);
digitalWrite(44, LOW); // PL5 relay reset HIGH=Energized
delay(2);
// Energize one range relay
digitalWrite(45, HIGH); // PL4 range 4 HIGH=Energized
delay(2);
digitalWrite(45, LOW); // PL4 range 4 HIGH=Energized
ReferenceOhm = (double)200000.0;
}
unsigned long delay2msAD5933UntilReady()
{
unsigned long start = millis();
byte r8F;
myGLCD.setFont(SmallFont);
myGLCD.setColor(255, 128, 128);
myGLCD.print("" "", 461, 1);
for (int i = 0; i < 100; i++) {
delay(2);
r8F = readAD5933(0x8F);
if ((r8F & 0x02) == 0) {
myGLCD.print(""?"", 461, 1);
}
else
{
myGLCD.print(""R"", 461, 1);
break;
}
}
return millis() - start;
}
void displayR80()
{
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
myGLCD.print(formatHEX8(readAD5933(0x80)), 81, 1);
}
void displayR81()
{
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
myGLCD.print(formatHEX8(readAD5933(0x81)), 97, 1);
}
void commandAD5933StanbyMode()
{
byte r80 = readAD5933(0x80);
r80 = 0xB0 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933Reset()
{
byte r80 = readAD5933(0x80);
r80 = 0x80 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933ExternalClock()
{
byte r81 = readAD5933(0x81);
r81 = 0x08 | (r81 & 0xF7);
writeAD5933(0x81, r81);
displayR81();
}
void commandAD5933InitializeWithStartFrequency()
{
byte r80 = readAD5933(0x80);
r80 = 0x10 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933StartFrequencySweep()
{
byte r80 = readAD5933(0x80);
r80 = 0x20 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933RepeatFrequency()
{
byte r80 = readAD5933(0x80);
r80 = 0x40 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933IncrementFrequency()
{
byte r80 = readAD5933(0x80);
r80 = 0x30 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933MeasureTemperature()
{
byte r80 = readAD5933(0x80);
r80 = 0x90 | (r80 & 0x0F);
writeAD5933(0x80, r80);
displayR80();
}
void commandAD5933Voltage3V()
{
byte r80 = readAD5933(0x80);
r80 = 0x00 | (r80 & 0xF9);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""3000mV"", 217, 12);
}
void commandAD5933Voltage1500mV()
{
byte r80 = readAD5933(0x80);
r80 = 0x06 | (r80 & 0xF9);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""1500mV"", 217, 12);
}
void commandAD5933Voltage600mV()
{
byte r80 = readAD5933(0x80);
r80 = 0x04 | (r80 & 0xF9);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""600mV "", 217, 12);
}
void commandAD5933Voltage300mV()
{
byte r80 = readAD5933(0x80);
r80 = 0x02 | (r80 & 0xF9);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""300mV "", 217, 12);
}
void commandAD5933GainX1()
{
byte r80 = readAD5933(0x80);
r80 = 0x01 | (r80 & 0xFE);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""x1"", 313, 1);
}
void commandAD5933GainX5()
{
byte r80 = readAD5933(0x80);
r80 = 0x00 | (r80 & 0xFE);
writeAD5933(0x80, r80);
displayR80();
myGLCD.print(""x5"", 313, 1);
}
void displayGrid()
{
//myGLCD.setFont(BigFont);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
myGLCD.print("" Command"", 1, 1); myGLCD.print(""Temperature"", 121, 1); myGLCD.print("" Gain"", 241, 1); myGLCD.print("" Status"", 361, 1);
myGLCD.print("" Settling"", 1, 12); myGLCD.print(""P-P Voltage"", 121, 12); myGLCD.print("" Step"", 241, 12); myGLCD.print(""Increments"", 361, 12);
myGLCD.print(""Frequency"", 1, 24);
myGLCD.print(""ReI"", 1, 48); myGLCD.print(""ReV"", 121, 48); myGLCD.print(""Absolute V"", 241, 48);
myGLCD.print(""ImI"", 1, 60); myGLCD.print(""ImV"", 121, 60); myGLCD.print(""Angle Volt"", 241, 60);
myGLCD.print(""AbI"", 1, 72); myGLCD.print(""AbV"", 121, 72); myGLCD.print(""Angle Curr"", 241, 72);
myGLCD.print(""AnI"", 1, 84); myGLCD.print(""AnV"", 121, 84); myGLCD.print(""Angle Loss"", 241, 84);
myGLCD.setFont(BigFont);
myGLCD.setColor(255, 255, 0);
myGLCD.print(""D "", 1, 100);
myGLCD.print(""Q "", 1, 120);
myGLCD.print(""Z,Ohm"", 1, 140);
myGLCD.print(""R,Ohm"", 1, 160);
myGLCD.print(""C,nF "", 1, 180);
myGLCD.print(""L,uH "", 1, 200);
}
void displayTemperature()
{
commandAD5933MeasureTemperature(); // measure temperature command
byte r8F;
do {
r8F = readAD5933(0x8F) & 0x07;
if ((r8F & 0x01) == 0) {
delay(10);
}
} while ((r8F & 0x01) == 0);
double TempC = readAD5933TemperatureC();
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
myGLCD.printNumF(TempC, 0, 209, 1, '.', 5);
}
void display14BitData(double value, short X, short Y)
{
if (abs(value) > 16383) {
myGLCD.setBackColor(255, 255, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.printNumF(value, 3, X, Y, '.', 9);
myGLCD.setBackColor(0, 0, 0);
myGLCD.setColor(128, 128, 255);
} else
{
myGLCD.printNumF(value, 3, X, Y, '.', 9);
}
}
void display9PosData(double value, double maxabs, short X, short Y)
{
byte usedlen = 0;
if (value < 0) usedlen++; // 1 position is used for sign
}
void displayData()
{
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
byte r8F = readAD5933(0x8F);
if ((r8F & 0x01) != 0) myGLCD.print(""T"", 449, 1); else myGLCD.print(""?"", 449, 1);
if ((r8F & 0x02) != 0) myGLCD.print(""D"", 461, 1); else myGLCD.print(""?"", 461, 1);
if ((r8F & 0x04) != 0) myGLCD.print(""S"", 473, 1); else myGLCD.print(""?"", 473, 1);
display14BitData(totalReI, 41, 48); display14BitData(totalReV, 161, 48);
display14BitData(totalImI, 41, 60); display14BitData(totalImV, 161, 60);
double AbV = sqrt(sq(totalReV) + sq(totalImV));
myGLCD.printNumF(AbV, 3, 161, 72, '.', 9);
double AnV = (atan2(totalImV, totalReV) / M_PI) * (double)180.0;
myGLCD.printNumF(AnV, 3, 161, 84, '.', 9);
// get frequency
double frequencyHz = readAD5933FrequencyHz();
// subtract current sense voltage from high potential voltage to get voltage of DUT
totalReV = totalReV - totalReI;
totalImV = totalImV - totalImI;
BigNumber pie(""3.141592653589793238"");
char tmp[20];
BigNumber bnTotalReV(dtostrf(totalReV, 9, 9, tmp));
BigNumber bnTotalImV(dtostrf(totalImV, 9, 9, tmp));
BigNumber bnAbV = bnTotalReV * bnTotalReV + bnTotalImV * bnTotalImV;
bnAbV = bnAbV.sqrt();
BigNumber bn180(180);
AbV = sqrt(sq(totalReV) + sq(totalImV));
AnV = (atan2(totalImV, totalReV) / M_PI) * (double)180.0;
BigNumber bnAnV = (atan2(bnTotalImV, bnTotalReV) / pie) * bn180;
// compute parasitic current of probe 28.3pF Xprobe = 1/2PifC
//double Xprobe = (double)1.0/((double)2.0 * M_PI * frequencyHz * (double)0.0000283);
BigNumber one(1);
BigNumber two(2);
BigNumber bnFrequencyHz(dtostrf(frequencyHz, 9, 9, tmp));
//BigNumber bnProbe_pF(""0.0000000000283"");
BigNumber bnProbe_pF(""0.0000000000"");
BigNumber bnXprobe = one / (two * pie * bnFrequencyHz * bnProbe_pF);
double probeImI = 0.0; /// AbV / Xprobe;
BigNumber bnProbeImI = bnAbV / bnXprobe;
BigNumber bnReferenceOhm(dtostrf(ReferenceOhm, 9, 9, tmp));
bnProbeImI = bnProbeImI * bnReferenceOhm; // brought correction value to Volts units
probeImI = probeImI / (double)1000000.0;
double AbI = sqrt(sq(totalReI) + sq(totalImI));
myGLCD.printNumF(AbI, 3, 41, 72, '.', 9);
/*
BigNumber bnTotalReI(dtostrf(totalReI, 9, 9, tmp));
BigNumber bnTotalImI(dtostrf(totalImI, 9, 9, tmp));
BigNumber bnAbI = bnTotalReI*bnTotalReI + bnTotalImI*bnTotalImI;
bnAbI = bnAbI.sqrt();
BigNumber bnAnI = (atan2(bnTotalImI, bnTotalReI)/pie)*bn180;
char * buf = bnAbI.toString();
myGLCD.print(buf, 41, 72);
free(buf);
*/
double AnI = (atan2(totalImI, totalReI) / M_PI) * (double)180.0;
myGLCD.printNumF(AnI, 3, 41, 84, '.', 9);
/*
buf = bnAnI.toString();
myGLCD.print(buf, 41, 84);
free(buf);
*/
AnI = AnI - AnV;
if (AnI > (double) 180.0) AnI = AnI - (double)360.0;
if (AnI < (double) - 180.0) AnI = AnI + (double)360.0;
// Complex current components after making AnV=0
totalReI = AbI * cos(AnI * M_PI / (double)180.0);
totalImI = AbI * sin(AnI * M_PI / (double)180.0);
// correct totalImI, AbI and AnI for probe current
totalImI = totalImI - (-probeImI); // correction looks like addition, because we subtracting negative
AbI = sqrt(sq(totalReI) + sq(totalImI));
AnI = (atan2(totalImI, totalReI) / M_PI) * (double)180.0;
// correct current angle for -0.41 degrees for known resistive DUT
// correct current angle for +0.177 degrees for known resistive DUT
//AnI = AnI - (double)0.360 + (double)0.125 + (double)0.213;
//AnI = AnI - (double)0.177;
//AnI = AnI + (double)13.900;
//AnI = AnI + (double)0.300;
AnI = AnI - (double)3.286; // 64 gain I, 1:1 gain V, @10KHz, 0.24Ohm range
if (AnI > (double) 180.0) AnI = AnI - (double)360.0;
if (AnI < (double) - 180.0) AnI = AnI + (double)360.0;
totalReI = AbI * cos(AnI * M_PI / (double)180.0);
totalImI = AbI * sin(AnI * M_PI / (double)180.0);
// find current amplitude from current sensor voltage
AbI = AbI / ReferenceOhm;
totalReI = totalReI / ReferenceOhm;
totalImI = totalImI / ReferenceOhm;
{
// Losses Angle
double lossA = (double)90.0 + AnI;
myGLCD.printNumF(AbV, 3, 329, 48, '.', 9);
myGLCD.printNumF(AnV, 3, 329, 60, '.', 9);
myGLCD.printNumF(AnI, 3, 329, 72, '.', 9);
myGLCD.printNumF(lossA, 3, 329, 84, '.', 9);
}
// complex impedance in ohms iz complex division of real voltage by (real current + imaginary current)
// (x+yi)/(u+vi)=((xu + yv)+(-xv+yu)i)/(u*u+v*v)
// then, when y=0
// x/(u+vi)=(xu-xvi)/(u*u+v*v)
// then for real and imaginary resistance component
// Rre = xu/(u*u+v*v)
// Rim = -xvi/(u*u+v*v)
//
// AbI is a square root, so unsquareroot it by multiplying by itself
// use AbI*AbI as ReI^2+ImI^2
double Rre = AbV * totalReI / (AbI * AbI);
double Rim = -AbV * totalImI / (AbI * AbI);
double tanLs = (Rre / Rim);
// Capacitance
double Cap = (double)(2.0) * M_PI * frequencyHz * Rim;
Cap = Cap / (double)1000000.0;
Cap = (double)1000.0 / Cap;
myGLCD.setFont(BigFont);
myGLCD.setColor(255, 255, 0);
myGLCD.printNumF(tanLs, 6, 100, 100, '.', 10);
double Q = abs(Rim / Rre);
myGLCD.printNumF(Q, 6, 100, 120, '.', 10);
double AbZ = sqrt(sq(Rre) + sq(Rim));
myGLCD.print("" "", 100, 140);
if (AbZ > 9999999.99) {
myGLCD.print(""INFINITY"", 100, 140);
} else {
myGLCD.printNumF(AbZ, 6, 100, 140, '.', 10);
}
myGLCD.printNumF(Rre, 6, 100, 160, '.', 10);
myGLCD.printNumF(Cap, 6, 100, 180, '.', 14);
// Inductance
double Ind = -Rim / ((double)(2.0) * M_PI * frequencyHz);
Ind = Ind * (double)1000000.0;
myGLCD.setColor(255, 255, 0);
myGLCD.print("" "", 100, 200);
if (abs(Ind) > 9999999.99) {
myGLCD.print(""INFINITY"", 100, 200);
} else {
myGLCD.printNumF(Ind, 6, 100, 200, '.', 10);
}
}
char formatHEX8Result[3];
char* formatHEX8(byte value)
{
sprintf(formatHEX8Result, ""%02X"", value);
formatHEX8Result[2] = 0;
return formatHEX8Result;
}
double readAD5933FrequencyHz()
{
long triple = 0;
long single = 0;
single = readAD5933(0x82);
triple = triple | (single << 16);
single = readAD5933(0x83);
triple = triple | (single << 8);
single = readAD5933(0x84);
triple = triple | (single << 0);
double TimeBaseDivideBy4 = TimeBaseFrequencyHz / (double)4.0;
double result = TimeBaseDivideBy4 * ((double)triple / (double)134217728.0); // 2^27;
return result;
}
void writeAD5933FrequencyHz(double valueHz)
{
double TimeBaseDivideBy4 = TimeBaseFrequencyHz / (double)4.0;
double phaseSpeed = valueHz / TimeBaseDivideBy4;
double controlDbl = phaseSpeed * (double)134217728.0;
long triple = (long)controlDbl;
byte single = 0;
single = (triple >> 16) & 0xFF;
writeAD5933(0x82, single);
single = (triple >> 8) & 0xFF;
writeAD5933(0x83, single);
single = (triple >> 0) & 0xFF;
writeAD5933(0x84, single);
double frequencyHz = readAD5933FrequencyHz();
myGLCD.setFont(SmallFont);
if (frequencyHz < TimeBaseDivideBy4 / 800.0 || frequencyHz > TimeBaseDivideBy4 / 20.0)
{
myGLCD.setBackColor(255, 255, 255);
myGLCD.setColor(255, 0, 0);
} else
{
myGLCD.setBackColor(0, 0, 0);
myGLCD.setColor(128, 128, 255);
}
myGLCD.setBackColor(0, 0, 0);
myGLCD.print("" "", 81, 24);
myGLCD.printNumI(round(frequencyHz), 81, 24, 5);
}
double readAD5933IncrementHz()
{
long triple = 0;
long single = 0;
single = readAD5933(0x85);
triple = triple | (single << 16);
single = readAD5933(0x86);
triple = triple | (single << 8);
single = readAD5933(0x87);
triple = triple | (single << 0);
double TimeBaseDivideBy4 = TimeBaseFrequencyHz / (double)4.0;
double result = TimeBaseDivideBy4 * ((double)triple / (double)134217728.0); // 2^27;
return result;
}
void writeAD5933IncrementHz(double valueHz)
{
double TimeBaseDivideBy4 = TimeBaseFrequencyHz / (double)4.0;
double phaseSpeed = valueHz / TimeBaseDivideBy4;
double controlDbl = phaseSpeed * (double)134217728.0;
long triple = (long)controlDbl;
byte single = 0;
single = (triple >> 16) & 0xFF;
writeAD5933(0x85, single);
single = (triple >> 8) & 0xFF;
writeAD5933(0x86, single);
single = (triple >> 0) & 0xFF;
writeAD5933(0x87, single);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
double incrementHz = readAD5933IncrementHz();
myGLCD.printNumI(round(incrementHz), 313, 12, 4);
}
word readAD5933IncrementsN()
{
word result = 0;
word single = 0;
single = readAD5933(0x88);
result = result | ((single & 0x01) << 8);
single = readAD5933(0x89);
result = result | ((single & 0xFF) << 0);
return result;
}
void writeAD5933IncrementsN(word le511)
{
byte single = 0;
single = (le511 >> 8) & 0x01;
writeAD5933(0x88, single);
single = (le511 >> 0) & 0xFF;
writeAD5933(0x89, single);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
le511 = readAD5933IncrementsN();
myGLCD.printNumI(le511, 449, 12, 4);
}
word readAD5933SettlingCnt()
{
word r8A = readAD5933(0x8A);
word r8B = readAD5933(0x8B);
word result = r8B | ((r8A & 0x01) << 8);
if ((r8A & 0x06) == 0x06) {
result = result * 4;
} else if ((r8A & 0x06) == 0x02)
{
result = result * 2;
};
return result;
}
void writeAD5933SettlingCnt(word le2044)
{
byte r8A = 0;
byte r8B = 0;
if (le2044 > 1022)
{
r8A = 0x06 | ((le2044 >> 10) & 0x01); // use x4 multiplier and occupy 1 MSb
r8B = (le2044 >> 2) & 0xFF; // occupy 8 LSb
} else if (le2044 > 511)
{
r8A = 0x02 | ((le2044 >> 9) & 0x01); // use x2 multiplier and occupy 1 MSb
r8B = (le2044 >> 1) & 0xFF; // occupy 8 LSb
} else
{
r8A = 0x00 | ((le2044 >> 8) & 0x01); // use x1 multiplier and occupy 1 MSb
r8B = (le2044 >> 0) & 0xFF; // occupy 8 LSb
}
writeAD5933(0x8A, r8A);
writeAD5933(0x8B, r8B);
myGLCD.setFont(SmallFont);
myGLCD.setColor(128, 128, 255);
le2044 = readAD5933SettlingCnt();
myGLCD.printNumI(le2044, 81, 12, 4);
}
double readAD5933TemperatureC()
{
long r92 = readAD5933(0x92);
r92 = r92 << 26;
long r93 = readAD5933(0x93);
r93 = r93 << 18;
long ival = r92 | r93;
ival = ival / 262144;
double result = (double)ival * (double)0.03125;
return result;
}
double readAD5933RealData()
{
int ival = (readAD5933(0x94) << 8) | readAD5933(0x95);
double result = (double)ival;
return result;
}
double readAD5933ImaginaryData()
{
int ival = (readAD5933(0x96) << 8) | readAD5933(0x97);
double result = (double)ival;
return result;
}
byte readAD5933(byte registerNumber)
{
byte twoBytes[2];
twoBytes[0] = 0xB0; // Pointer Command
twoBytes[1] = registerNumber; // Register 0x80..0x9X
Wire.beginTransmission(0x0D); // 0x0D is I2C 7 bit address of AD5933
Wire.write(twoBytes, 2);
Wire.endTransmission();
Wire.requestFrom(0x0D, 1, true); // 0x0D is I2C 7 bit address of AD5933
byte result = Wire.read(); // read one byte
return result;
}
void writeAD5933(byte registerNumber, byte value)
{
byte twoBytes[2];
twoBytes[0] = registerNumber; // Register 0x80..0x9X
twoBytes[1] = value; // value
Wire.beginTransmission(0x0D); // 0x0D is I2C 7 bit address of AD5933
Wire.write(twoBytes, 2);
Wire.endTransmission();
}
",12449,False,2101.628744544637,median
"/*
FlipMode.ino
Test flip functionality (180 degree roation)
Note: Not supported with all displays
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#ifdef U8X8_HAVE_HW_SPI
#include
#endif
// Please UNCOMMENT one of the contructor lines below
// U8x8 Contructor List
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8x8setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8X8_NULL u8x8; // null device, a 8x8 pixel display which does nothing
//U8X8_SSD1306_128X64_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 6, /* dc=*/ 4, /* reset=*/ 12); // Arduboy (DevKit)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6); // Arduboy 10 (Production, Kickstarter Edition)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_3W_HW_SPI u8x8(/* cs=*/ 10, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_128X64_ALT0_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ 2, /* data=*/ 0, /* reset=*/ U8X8_PIN_NONE); // Digispark ATTiny85
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // OLEDs without Reset of the Display
//U8X8_SSD1306_128X64_VCOMH0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8X8_SSD1306_128X64_ALT0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8X8_SH1106_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1106_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1106_128X64_VCOMH0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8X8_SH1106_128X64_WINSTAR_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but uses updated SH1106 init sequence
//U8X8_SH1106_128X32_VISIONOX_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1106_128X32_VISIONOX_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1106_72X40_WISE_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_64X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1107_128X128_HW_I2C u8x8(/* reset=*/ 8);
//U8X8_SH1107_PIMORONI_128X128_HW_I2C u8x8(/* reset=*/ 8);
//U8X8_SH1107_SEEED_128X128_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1107_SEEED_128X128_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SH1107_SEEED_96X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SH1108_160X160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8X8_SSD1306_128X32_WINSTAR_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8X8_SSD1306_64X48_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8X8_SSD1306_48X64_WINSTAR_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_64X32_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_64X32_1F_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_96X16_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.69""
//U8X8_SSD1306_72X40_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // EastRising 0.42""
//U8X8_SSD1306_128X64_NONAME_6800 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_8080 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME0_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME2_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1309_128X64_NONAME2_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1316_128X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1316_128X32_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1317_96X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // not tested, not confirmed
//U8X8_SSD1317_96X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // not tested, not confirmed
//U8X8_SSD1318_128X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1318_128X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1320_160X132_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1320_160X132_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_256X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_256X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1322_NHD_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1325_NHD_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1325_NHD_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD0323_OS128064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD0323_OS128064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1326_ER_256X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // experimental driver for ER-OLED018-1
//U8X8_SSD1327_SEEED_96X96_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8X8_SSD1327_SEEED_96X96_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8X8_SSD1327_EA_W128128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_EA_W128128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_MIDAS_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_MIDAS_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_WS_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_WS_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_VISIONOX_128X96_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1327_VISIONOX_128X96_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_128X96_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_128X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1329_96X96_NONAME_4W_HW_SPI u8x8(/* cs=*/ A4, /* dc=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather 32u4 Basic Proto
//U8X8_SSD1305_128X32_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_ADAFRUIT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X32_ADAFRUIT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_ADAFRUIT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_ADAFRUIT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_RAYSTAR_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1305_128X64_RAYSTAR_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_KS0108_128X64 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_KS0108_ERM19264 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_HD44102_100X64 u8x8(4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_T7932_150X32 u8x8(4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8X8_UC1701_EA_DOGS102_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1701_EA_DOGS102_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_PCD8544_84X48_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8X8_PCD8544_84X48_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8X8_PCF8812_96X65_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8X8_PCF8812_96X65_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8X8_HX1230_96X68_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_HX1230_96X68_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7528_ERC16064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7528_ERC16064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_64128N_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_64128N_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_EA_DOGM132_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8X8_ST7565_EA_DOGM132_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8X8_ST7565_ZOLEN_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ZOLEN_128X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_LM6059_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8X8_ST7565_LM6059_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8X8_ST7565_KS0713_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // KS0713 controller
//U8X8_ST7565_KS0713_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // KS0713 controller
//U8X8_ST7565_LX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_LX12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_ERC12864_ALT_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8X8_ST7565_ERC12864_ALT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
//U8X8_ST7565_NHD_C12832_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12832_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_NHD_C12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_JLX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7565_JLX12864_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_PI_132X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8X8_ST7567_PI_132X64_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8X8_ST7567_JLX12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_JLX12864_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_OS12864_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_OS12864_4W_HW_SPI u8x8(/* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064I_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_ENH_DG128064I_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7567_64X32_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_ST7567_HEM6432_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_ST7571_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7571_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX172104_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX172104_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX19296_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX19296_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_WO256X128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_WO256X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160M_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160M_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_ALT_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX256160_ALT_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX240160_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX240160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75256_JLX25664_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C
//U8X8_ST75320_JLX320240_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST75320_JLX320240_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_NT7534_TG12864R_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_NT7534_TG12864R_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_ST7588_JLX12864_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
//U8X8_ST7588_JLX12864_HW_I2C u8x8(/* reset=*/ 5);
//U8X8_IST3020_ERC19264_6800 u8x8(44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8X8_IST3020_ERC19264_8080 u8x8(44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8X8_IST3020_ERC19264_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_IST7920_128X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Round display
//U8X8_IST7920_128X128_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Round display
//U8X8_UC1601_128X32_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1601_128X32_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8X8_UC1601_128X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1604_JLX19264_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1604_JLX19264_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1608_ERC24064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, ERC24064-1 Test Board
//U8X8_UC1608_DEM240064_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, ERC24064-1 Test Board
//U8X8_UC1608_ERC240120_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1608_240X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1610_EA_DOGXL160_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8X8_UC1610_EA_DOGXL160_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8X8_UC1611_EA_DOGM240_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C, DOGM240 Test Board
//U8X8_UC1611_EA_DOGM240_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8X8_UC1611_EA_DOGXL240_2ND_HW_I2C u8x8(/* reset=*/ 8); // Due, 2nd I2C, DOGXL240 Test Board
//U8X8_UC1611_EA_DOGXL240_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8X8_UC1611_IDS4073_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1611_IDS4073_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1611_EW50850_8080 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8X8_UC1611_CG160160_8080 u8x8(8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
//U8X8_UC1617_JLX128128_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1617_JLX128128_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_4W_SW_SPI u8x8( /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_4W_HW_SPI u8x8( /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_UC1638_192X96_SW_I2C u8x8(/* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8); // u8g2 test board: I2C clock/data is same as SPI, I2C default address is 0x78
//U8X8_SSD1606_172X72_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display
//U8X8_SSD1607_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT from embedded artists
//U8X8_SSD1607_GS_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Good Display
//U8X8_SSD1607_WS_200X200_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Waveshare
//U8X8_IL3820_296X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT
//U8X8_IL3820_V2_296X128_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, optimized (lesser screen flicker)
//U8X8_ST7511_AVD_320X240_8080 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Connect RD pin with 3.3V/5V
//U8X8_S1D15721_240X64_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_S1D15721_240X64_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
// End of constructor list
void setup(void)
{
/* U8g2 Project: Pax Instruments Shield: Enable Backlight */
//pinMode(6, OUTPUT);
//digitalWrite(6, 0);
u8x8.begin();
}
void loop(void)
{
u8x8.setFont(u8x8_font_chroma48medium8_r);
u8x8.clear();
u8x8.setFlipMode(0);
u8x8.setInverseFont(1);
u8x8.drawString(0,0,""FlipMode 0"");
u8x8.setInverseFont(0);
u8x8.drawString(1,1,""FlipMode 0"");
delay(1500);
u8x8.clear();
u8x8.setFlipMode(1);
u8x8.setInverseFont(1);
u8x8.drawString(0,0,""FlipMode 1"");
u8x8.setInverseFont(0);
u8x8.drawString(1,1,""FlipMode 1"");
delay(1500);
}
",12229,True,3692.754413006916,median
"###############################################################################
# Copyright 2019 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material (""Material"") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# ""License""), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.section .note.GNU-stack,"""",%progbits
.text
.p2align 5, 0x90
CONST_TABLE:
_poly:
.quad 0x1, 0xC200000000000000
_twoone:
.quad 0x1, 0x100000000
_u128_str:
.byte 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
_mask1:
.quad 0xffffffffffffffff, 0x0
_mask2:
.quad 0x0, 0xffffffffffffffff
_inc1:
.quad 1,0
.p2align 5, 0x90
.globl h9_AesGcmPrecompute_avx
.type h9_AesGcmPrecompute_avx, @function
h9_AesGcmPrecompute_avx:
push %ebp
mov %esp, %ebp
push %esi
lea CONST_TABLE, %esi
movl (8)(%ebp), %eax
movdqu (%eax), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm0
psrlq $(63), %xmm4
movdqa %xmm4, %xmm3
pslldq $(8), %xmm4
psrldq $(8), %xmm3
por %xmm4, %xmm0
pshufd $(36), %xmm3, %xmm4
pcmpeqd ((_twoone-CONST_TABLE))(%esi), %xmm4
pand ((_poly-CONST_TABLE))(%esi), %xmm4
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm1
pshufd $(78), %xmm1, %xmm5
pshufd $(78), %xmm0, %xmm3
pxor %xmm1, %xmm5
pxor %xmm0, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm1, %xmm4
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm0, %xmm4
pxor %xmm1, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm3
psllq $(1), %xmm3
pxor %xmm1, %xmm3
psllq $(5), %xmm3
pxor %xmm1, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm1
pxor %xmm3, %xmm4
movdqa %xmm1, %xmm5
psrlq $(5), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm1
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm5
pshufd $(78), %xmm1, %xmm3
pxor %xmm2, %xmm5
pxor %xmm1, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm2, %xmm4
pclmulqdq $(0), %xmm1, %xmm2
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm1, %xmm4
pxor %xmm2, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm3
psllq $(1), %xmm3
pxor %xmm2, %xmm3
psllq $(5), %xmm3
pxor %xmm2, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm2, %xmm5
psrlq $(5), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm2
pxor %xmm4, %xmm2
movl (12)(%ebp), %eax
movdqu %xmm0, (%eax)
movdqu %xmm1, (16)(%eax)
movdqu %xmm2, (32)(%eax)
pop %esi
pop %ebp
ret
.Lfe1:
.size h9_AesGcmPrecompute_avx, .Lfe1-(h9_AesGcmPrecompute_avx)
.p2align 5, 0x90
.globl h9_AesGcmMulGcm_avx
.type h9_AesGcmMulGcm_avx, @function
h9_AesGcmMulGcm_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
lea CONST_TABLE, %esi
movl (8)(%ebp), %edi
movl (12)(%ebp), %eax
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.Lfe2:
.size h9_AesGcmMulGcm_avx, .Lfe2-(h9_AesGcmMulGcm_avx)
.p2align 5, 0x90
.globl h9_AesGcmAuth_avx
.type h9_AesGcmAuth_avx, @function
h9_AesGcmAuth_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
lea CONST_TABLE, %esi
movl (8)(%ebp), %edi
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movl (20)(%ebp), %eax
movdqa (%eax), %xmm1
movl (12)(%ebp), %ecx
movl (16)(%ebp), %edx
.p2align 5, 0x90
.Lauth_loopgas_3:
movdqu (%ecx), %xmm2
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm2
add $(16), %ecx
pxor %xmm2, %xmm0
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
sub $(16), %edx
jnz .Lauth_loopgas_3
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.Lfe3:
.size h9_AesGcmAuth_avx, .Lfe3-(h9_AesGcmAuth_avx)
.p2align 5, 0x90
.globl h9_AesGcmEnc_avx
.type h9_AesGcmEnc_avx, @function
h9_AesGcmEnc_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
lea CONST_TABLE, %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_4
.p2align 5, 0x90
.Lblks4_loopgas_4:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher4_loopgas_4:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_4
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm1
pxor (48)(%ebx), %xmm1
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm2
pxor (64)(%ebx), %xmm2
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm3
pxor (80)(%ebx), %xmm3
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm7
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_4
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
movdqa %xmm0, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm2, (64)(%ebx)
movdqa %xmm3, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_4
.Lcombine_hashgas_4:
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
movdqa (16)(%eax), %xmm7
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
movdqa (%eax), %xmm7
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pxor %xmm1, %xmm3
pxor %xmm2, %xmm3
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
pxor %xmm0, %xmm3
movdqa %xmm3, (32)(%ebx)
.Lsingle_block_procgas_4:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_4
.p2align 5, 0x90
.Lblk_loopgas_4:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher_loopgas_4:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_4
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
movdqa %xmm0, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_4
.Lquitgas_4:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lfe4:
.size h9_AesGcmEnc_avx, .Lfe4-(h9_AesGcmEnc_avx)
.p2align 5, 0x90
.globl h9_AesGcmDec_avx
.type h9_AesGcmDec_avx, @function
h9_AesGcmDec_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
lea CONST_TABLE, %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_5
.p2align 5, 0x90
.Lblks4_loopgas_5:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher4_loopgas_5:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_5
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm4
pxor (32)(%ebx), %xmm4
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm5
pxor (48)(%ebx), %xmm5
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm6
pxor (64)(%ebx), %xmm6
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm7
pxor (80)(%ebx), %xmm7
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm0
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_5
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
movdqa %xmm4, (32)(%ebx)
movdqa %xmm5, (48)(%ebx)
movdqa %xmm6, (64)(%ebx)
movdqa %xmm7, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_5
.Lcombine_hashgas_5:
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
movdqa (16)(%eax), %xmm0
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
movdqa (%eax), %xmm0
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pxor %xmm5, %xmm7
pxor %xmm6, %xmm7
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, (32)(%ebx)
.Lsingle_block_procgas_5:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_5
.p2align 5, 0x90
.Lblk_loopgas_5:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher_loopgas_5:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_5
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm1
pxor (32)(%ebx), %xmm1
movdqa (%eax), %xmm0
pshufd $(78), %xmm1, %xmm4
pshufd $(78), %xmm0, %xmm2
pxor %xmm1, %xmm4
pxor %xmm0, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm1, %xmm3
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm0, %xmm3
pxor %xmm1, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
psllq $(1), %xmm2
pxor %xmm1, %xmm2
psllq $(5), %xmm2
pxor %xmm1, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm1
pxor %xmm2, %xmm3
movdqa %xmm1, %xmm4
psrlq $(5), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm1
pxor %xmm3, %xmm1
movdqa %xmm1, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_5
.Lquitgas_5:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lfe5:
.size h9_AesGcmDec_avx, .Lfe5-(h9_AesGcmDec_avx)
",16332,True,4909.917908079138,median
"/*
PrintProgmem.ino
AVR Architecture:
Use the (Arduino compatible) u8g2 function ""print"" to draw a string,
which is located in PROGMEM.
For string constants use the F() macro, but this example use global
strings instead.
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#ifdef U8X8_HAVE_HW_SPI
#include
#endif
#ifdef U8X8_HAVE_HW_I2C
#include
#endif
/*
U8glib Example Overview:
Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
This is a page buffer example.
*/
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0); // null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6); // Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE); // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17); // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.69"" OLED
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8); // SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE); // NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */); // Remember to set R/W to 0
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/ A4); // Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); // Not tested
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Good Display
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
// End of constructor list
void setup(void) {
u8g2.begin();
}
const char s[] PROGMEM = ""Progmem"";
const char s1[] PROGMEM = ""ABC"" ;
const char s2[] PROGMEM = ""DEF"" ;
const char s3[] PROGMEM = ""GHI"" ;
const char s4[] PROGMEM = ""JKL"" ;
const char *a[] = { s1, s2, s3, s4 };
int i = 0;
void loop(void) {
u8g2.setFont(u8g2_font_ncenB14_tr);
u8g2.firstPage();
do {
u8g2.setCursor(0, 20);
u8g2.print((class __FlashStringHelper *)s); // print a sting, located in PROGMEM
u8g2.setCursor(0, 40);
u8g2.print((class __FlashStringHelper *)a[i]); // print a sting (PROGMEM) via RAM array.
} while ( u8g2.nextPage() );
delay(1000);
i++;
if ( i >= 4 )
i = 0;
}
",12072,True,3685.962208294028,median
"/*
* Copyright 2018 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the ""Software""),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
var SQ_WAVE_STATUS_INST_ATC_SHIFT = 23
var SQ_WAVE_STATUS_INST_ATC_MASK = 0x00800000
var SQ_WAVE_STATUS_SPI_PRIO_MASK = 0x00000006
var SQ_WAVE_STATUS_HALT_MASK = 0x2000
var SQ_WAVE_LDS_ALLOC_LDS_SIZE_SHIFT = 12
var SQ_WAVE_LDS_ALLOC_LDS_SIZE_SIZE = 9
var SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SHIFT = 8
var SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SIZE = 6
var SQ_WAVE_GPR_ALLOC_SGPR_SIZE_SHIFT = 24
var SQ_WAVE_GPR_ALLOC_SGPR_SIZE_SIZE = 4
var SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SHIFT = 24
var SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SIZE = 4
var SQ_WAVE_IB_STS2_WAVE64_SHIFT = 11
var SQ_WAVE_IB_STS2_WAVE64_SIZE = 1
var SQ_WAVE_TRAPSTS_SAVECTX_MASK = 0x400
var SQ_WAVE_TRAPSTS_EXCE_MASK = 0x1FF
var SQ_WAVE_TRAPSTS_SAVECTX_SHIFT = 10
var SQ_WAVE_TRAPSTS_MEM_VIOL_MASK = 0x100
var SQ_WAVE_TRAPSTS_MEM_VIOL_SHIFT = 8
var SQ_WAVE_TRAPSTS_PRE_SAVECTX_MASK = 0x3FF
var SQ_WAVE_TRAPSTS_PRE_SAVECTX_SHIFT = 0x0
var SQ_WAVE_TRAPSTS_PRE_SAVECTX_SIZE = 10
var SQ_WAVE_TRAPSTS_POST_SAVECTX_MASK = 0xFFFFF800
var SQ_WAVE_TRAPSTS_POST_SAVECTX_SHIFT = 11
var SQ_WAVE_TRAPSTS_POST_SAVECTX_SIZE = 21
var SQ_WAVE_TRAPSTS_ILLEGAL_INST_MASK = 0x800
var SQ_WAVE_IB_STS_RCNT_SHIFT = 16
var SQ_WAVE_IB_STS_FIRST_REPLAY_SHIFT = 15
var SQ_WAVE_IB_STS_REPLAY_W64H_SHIFT = 25
var SQ_WAVE_IB_STS_REPLAY_W64H_SIZE = 1
var SQ_WAVE_IB_STS_REPLAY_W64H_MASK = 0x02000000
var SQ_WAVE_IB_STS_FIRST_REPLAY_SIZE = 1
var SQ_WAVE_IB_STS_RCNT_SIZE = 6
var SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK = 0x003F8000
var SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK_NEG = 0x00007FFF
var SQ_BUF_RSRC_WORD1_ATC_SHIFT = 24
var SQ_BUF_RSRC_WORD3_MTYPE_SHIFT = 27
// bits [31:24] unused by SPI debug data
var TTMP11_SAVE_REPLAY_W64H_SHIFT = 31
var TTMP11_SAVE_REPLAY_W64H_MASK = 0x80000000
var TTMP11_SAVE_RCNT_FIRST_REPLAY_SHIFT = 24
var TTMP11_SAVE_RCNT_FIRST_REPLAY_MASK = 0x7F000000
// SQ_SEL_X/Y/Z/W, BUF_NUM_FORMAT_FLOAT, (0 for MUBUF stride[17:14]
// when ADD_TID_ENABLE and BUF_DATA_FORMAT_32 for MTBUF), ADD_TID_ENABLE
var S_SAVE_BUF_RSRC_WORD1_STRIDE = 0x00040000
var S_SAVE_BUF_RSRC_WORD3_MISC = 0x10807FAC
var S_SAVE_SPI_INIT_ATC_MASK = 0x08000000
var S_SAVE_SPI_INIT_ATC_SHIFT = 27
var S_SAVE_SPI_INIT_MTYPE_MASK = 0x70000000
var S_SAVE_SPI_INIT_MTYPE_SHIFT = 28
var S_SAVE_SPI_INIT_FIRST_WAVE_MASK = 0x04000000
var S_SAVE_SPI_INIT_FIRST_WAVE_SHIFT = 26
var S_SAVE_PC_HI_RCNT_SHIFT = 26
var S_SAVE_PC_HI_RCNT_MASK = 0xFC000000
var S_SAVE_PC_HI_FIRST_REPLAY_SHIFT = 25
var S_SAVE_PC_HI_FIRST_REPLAY_MASK = 0x02000000
var S_SAVE_PC_HI_REPLAY_W64H_SHIFT = 24
var S_SAVE_PC_HI_REPLAY_W64H_MASK = 0x01000000
var s_sgpr_save_num = 108
var s_save_spi_init_lo = exec_lo
var s_save_spi_init_hi = exec_hi
var s_save_pc_lo = ttmp0
var s_save_pc_hi = ttmp1
var s_save_exec_lo = ttmp2
var s_save_exec_hi = ttmp3
var s_save_status = ttmp12
var s_save_trapsts = ttmp5
var s_save_xnack_mask = ttmp6
var s_wave_size = ttmp7
var s_save_buf_rsrc0 = ttmp8
var s_save_buf_rsrc1 = ttmp9
var s_save_buf_rsrc2 = ttmp10
var s_save_buf_rsrc3 = ttmp11
var s_save_mem_offset = ttmp14
var s_save_alloc_size = s_save_trapsts
var s_save_tmp = s_save_buf_rsrc2
var s_save_m0 = ttmp15
var S_RESTORE_BUF_RSRC_WORD1_STRIDE = S_SAVE_BUF_RSRC_WORD1_STRIDE
var S_RESTORE_BUF_RSRC_WORD3_MISC = S_SAVE_BUF_RSRC_WORD3_MISC
var S_RESTORE_SPI_INIT_ATC_MASK = 0x08000000
var S_RESTORE_SPI_INIT_ATC_SHIFT = 27
var S_RESTORE_SPI_INIT_MTYPE_MASK = 0x70000000
var S_RESTORE_SPI_INIT_MTYPE_SHIFT = 28
var S_RESTORE_SPI_INIT_FIRST_WAVE_MASK = 0x04000000
var S_RESTORE_SPI_INIT_FIRST_WAVE_SHIFT = 26
var S_WAVE_SIZE = 25
var S_RESTORE_PC_HI_RCNT_SHIFT = S_SAVE_PC_HI_RCNT_SHIFT
var S_RESTORE_PC_HI_RCNT_MASK = S_SAVE_PC_HI_RCNT_MASK
var S_RESTORE_PC_HI_FIRST_REPLAY_SHIFT = S_SAVE_PC_HI_FIRST_REPLAY_SHIFT
var S_RESTORE_PC_HI_FIRST_REPLAY_MASK = S_SAVE_PC_HI_FIRST_REPLAY_MASK
var s_restore_spi_init_lo = exec_lo
var s_restore_spi_init_hi = exec_hi
var s_restore_mem_offset = ttmp12
var s_restore_alloc_size = ttmp3
var s_restore_tmp = ttmp6
var s_restore_mem_offset_save = s_restore_tmp
var s_restore_m0 = s_restore_alloc_size
var s_restore_mode = ttmp7
var s_restore_flat_scratch = ttmp2
var s_restore_pc_lo = ttmp0
var s_restore_pc_hi = ttmp1
var s_restore_exec_lo = ttmp14
var s_restore_exec_hi = ttmp15
var s_restore_status = ttmp4
var s_restore_trapsts = ttmp5
var s_restore_xnack_mask = ttmp13
var s_restore_buf_rsrc0 = ttmp8
var s_restore_buf_rsrc1 = ttmp9
var s_restore_buf_rsrc2 = ttmp10
var s_restore_buf_rsrc3 = ttmp11
var s_restore_size = ttmp7
shader main
asic(DEFAULT)
type(CS)
wave_size(32)
s_branch L_SKIP_RESTORE //NOT restore. might be a regular trap or save
L_JUMP_TO_RESTORE:
s_branch L_RESTORE
L_SKIP_RESTORE:
s_getreg_b32 s_save_status, hwreg(HW_REG_STATUS) //save STATUS since we will change SCC
s_andn2_b32 s_save_status, s_save_status, SQ_WAVE_STATUS_SPI_PRIO_MASK
s_getreg_b32 s_save_trapsts, hwreg(HW_REG_TRAPSTS)
s_and_b32 ttmp2, s_save_trapsts, SQ_WAVE_TRAPSTS_SAVECTX_MASK //check whether this is for save
s_cbranch_scc1 L_SAVE
// If STATUS.MEM_VIOL is asserted then halt the wave to prevent
// the exception raising again and blocking context save.
s_and_b32 ttmp2, s_save_trapsts, SQ_WAVE_TRAPSTS_MEM_VIOL_MASK
s_cbranch_scc0 L_FETCH_2ND_TRAP
s_or_b32 s_save_status, s_save_status, SQ_WAVE_STATUS_HALT_MASK
L_FETCH_2ND_TRAP:
// Preserve and clear scalar XNACK state before issuing scalar loads.
// Save IB_STS.REPLAY_W64H[25], RCNT[21:16], FIRST_REPLAY[15] into
// unused space ttmp11[31:24].
s_andn2_b32 ttmp11, ttmp11, (TTMP11_SAVE_REPLAY_W64H_MASK | TTMP11_SAVE_RCNT_FIRST_REPLAY_MASK)
s_getreg_b32 ttmp2, hwreg(HW_REG_IB_STS)
s_and_b32 ttmp3, ttmp2, SQ_WAVE_IB_STS_REPLAY_W64H_MASK
s_lshl_b32 ttmp3, ttmp3, (TTMP11_SAVE_REPLAY_W64H_SHIFT - SQ_WAVE_IB_STS_REPLAY_W64H_SHIFT)
s_or_b32 ttmp11, ttmp11, ttmp3
s_and_b32 ttmp3, ttmp2, SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK
s_lshl_b32 ttmp3, ttmp3, (TTMP11_SAVE_RCNT_FIRST_REPLAY_SHIFT - SQ_WAVE_IB_STS_FIRST_REPLAY_SHIFT)
s_or_b32 ttmp11, ttmp11, ttmp3
s_andn2_b32 ttmp2, ttmp2, (SQ_WAVE_IB_STS_REPLAY_W64H_MASK | SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK)
s_setreg_b32 hwreg(HW_REG_IB_STS), ttmp2
// Read second-level TBA/TMA from first-level TMA and jump if available.
// ttmp[2:5] and ttmp12 can be used (others hold SPI-initialized debug data)
// ttmp12 holds SQ_WAVE_STATUS
s_getreg_b32 ttmp14, hwreg(HW_REG_SHADER_TMA_LO)
s_getreg_b32 ttmp15, hwreg(HW_REG_SHADER_TMA_HI)
s_lshl_b64 [ttmp14, ttmp15], [ttmp14, ttmp15], 0x8
s_load_dwordx2 [ttmp2, ttmp3], [ttmp14, ttmp15], 0x0 glc:1 // second-level TBA
s_waitcnt lgkmcnt(0)
s_load_dwordx2 [ttmp14, ttmp15], [ttmp14, ttmp15], 0x8 glc:1 // second-level TMA
s_waitcnt lgkmcnt(0)
s_and_b64 [ttmp2, ttmp3], [ttmp2, ttmp3], [ttmp2, ttmp3]
s_cbranch_scc0 L_NO_NEXT_TRAP // second-level trap handler not been set
s_setpc_b64 [ttmp2, ttmp3] // jump to second-level trap handler
L_NO_NEXT_TRAP:
s_getreg_b32 s_save_trapsts, hwreg(HW_REG_TRAPSTS)
s_and_b32 s_save_trapsts, s_save_trapsts, SQ_WAVE_TRAPSTS_EXCE_MASK
s_cbranch_scc1 L_EXCP_CASE // Exception, jump back to the shader program directly.
s_add_u32 ttmp0, ttmp0, 4 // S_TRAP case, add 4 to ttmp0
s_addc_u32 ttmp1, ttmp1, 0
L_EXCP_CASE:
s_and_b32 ttmp1, ttmp1, 0xFFFF
// Restore SQ_WAVE_IB_STS.
s_lshr_b32 ttmp2, ttmp11, (TTMP11_SAVE_RCNT_FIRST_REPLAY_SHIFT - SQ_WAVE_IB_STS_FIRST_REPLAY_SHIFT)
s_and_b32 ttmp3, ttmp2, SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK
s_lshr_b32 ttmp2, ttmp11, (TTMP11_SAVE_REPLAY_W64H_SHIFT - SQ_WAVE_IB_STS_REPLAY_W64H_SHIFT)
s_and_b32 ttmp2, ttmp2, SQ_WAVE_IB_STS_REPLAY_W64H_MASK
s_or_b32 ttmp2, ttmp2, ttmp3
s_setreg_b32 hwreg(HW_REG_IB_STS), ttmp2
// Restore SQ_WAVE_STATUS.
s_and_b64 exec, exec, exec // Restore STATUS.EXECZ, not writable by s_setreg_b32
s_and_b64 vcc, vcc, vcc // Restore STATUS.VCCZ, not writable by s_setreg_b32
s_setreg_b32 hwreg(HW_REG_STATUS), s_save_status
s_rfe_b64 [ttmp0, ttmp1]
L_SAVE:
//check whether there is mem_viol
s_getreg_b32 s_save_trapsts, hwreg(HW_REG_TRAPSTS)
s_and_b32 s_save_trapsts, s_save_trapsts, SQ_WAVE_TRAPSTS_MEM_VIOL_MASK
s_cbranch_scc0 L_NO_PC_REWIND
//if so, need rewind PC assuming GDS operation gets NACKed
s_mov_b32 s_save_tmp, 0
s_setreg_b32 hwreg(HW_REG_TRAPSTS, SQ_WAVE_TRAPSTS_MEM_VIOL_SHIFT, 1), s_save_tmp //clear mem_viol bit
s_and_b32 s_save_pc_hi, s_save_pc_hi, 0x0000ffff //pc[47:32]
s_sub_u32 s_save_pc_lo, s_save_pc_lo, 8 //pc[31:0]-8
s_subb_u32 s_save_pc_hi, s_save_pc_hi, 0x0
L_NO_PC_REWIND:
s_mov_b32 s_save_tmp, 0
s_setreg_b32 hwreg(HW_REG_TRAPSTS, SQ_WAVE_TRAPSTS_SAVECTX_SHIFT, 1), s_save_tmp //clear saveCtx bit
s_getreg_b32 s_save_xnack_mask, hwreg(HW_REG_SHADER_XNACK_MASK)
s_getreg_b32 s_save_tmp, hwreg(HW_REG_IB_STS, SQ_WAVE_IB_STS_RCNT_SHIFT, SQ_WAVE_IB_STS_RCNT_SIZE)
s_lshl_b32 s_save_tmp, s_save_tmp, S_SAVE_PC_HI_RCNT_SHIFT
s_or_b32 s_save_pc_hi, s_save_pc_hi, s_save_tmp
s_getreg_b32 s_save_tmp, hwreg(HW_REG_IB_STS, SQ_WAVE_IB_STS_FIRST_REPLAY_SHIFT, SQ_WAVE_IB_STS_FIRST_REPLAY_SIZE)
s_lshl_b32 s_save_tmp, s_save_tmp, S_SAVE_PC_HI_FIRST_REPLAY_SHIFT
s_or_b32 s_save_pc_hi, s_save_pc_hi, s_save_tmp
s_getreg_b32 s_save_tmp, hwreg(HW_REG_IB_STS, SQ_WAVE_IB_STS_REPLAY_W64H_SHIFT, SQ_WAVE_IB_STS_REPLAY_W64H_SIZE)
s_lshl_b32 s_save_tmp, s_save_tmp, S_SAVE_PC_HI_REPLAY_W64H_SHIFT
s_or_b32 s_save_pc_hi, s_save_pc_hi, s_save_tmp
s_getreg_b32 s_save_tmp, hwreg(HW_REG_IB_STS) //clear RCNT and FIRST_REPLAY and REPLAY_W64H in IB_STS
s_and_b32 s_save_tmp, s_save_tmp, SQ_WAVE_IB_STS_RCNT_FIRST_REPLAY_MASK_NEG
s_setreg_b32 hwreg(HW_REG_IB_STS), s_save_tmp
/* inform SPI the readiness and wait for SPI's go signal */
s_mov_b32 s_save_exec_lo, exec_lo //save EXEC and use EXEC for the go signal from SPI
s_mov_b32 s_save_exec_hi, exec_hi
s_mov_b64 exec, 0x0 //clear EXEC to get ready to receive
s_sendmsg sendmsg(MSG_SAVEWAVE) //send SPI a message and wait for SPI's write to EXEC
L_SLEEP:
// sleep 1 (64clk) is not enough for 8 waves per SIMD, which will cause
// SQ hang, since the 7,8th wave could not get arbit to exec inst, while
// other waves are stuck into the sleep-loop and waiting for wrexec!=0
s_sleep 0x2
s_cbranch_execz L_SLEEP
/* setup Resource Contants */
s_mov_b32 s_save_buf_rsrc0, s_save_spi_init_lo //base_addr_lo
s_and_b32 s_save_buf_rsrc1, s_save_spi_init_hi, 0x0000FFFF //base_addr_hi
s_or_b32 s_save_buf_rsrc1, s_save_buf_rsrc1, S_SAVE_BUF_RSRC_WORD1_STRIDE
s_mov_b32 s_save_buf_rsrc2, 0 //NUM_RECORDS initial value = 0 (in bytes) although not neccessarily inited
s_mov_b32 s_save_buf_rsrc3, S_SAVE_BUF_RSRC_WORD3_MISC
s_and_b32 s_save_tmp, s_save_spi_init_hi, S_SAVE_SPI_INIT_ATC_MASK
s_lshr_b32 s_save_tmp, s_save_tmp, (S_SAVE_SPI_INIT_ATC_SHIFT-SQ_BUF_RSRC_WORD1_ATC_SHIFT)
s_or_b32 s_save_buf_rsrc3, s_save_buf_rsrc3, s_save_tmp //or ATC
s_and_b32 s_save_tmp, s_save_spi_init_hi, S_SAVE_SPI_INIT_MTYPE_MASK
s_lshr_b32 s_save_tmp, s_save_tmp, (S_SAVE_SPI_INIT_MTYPE_SHIFT-SQ_BUF_RSRC_WORD3_MTYPE_SHIFT)
s_or_b32 s_save_buf_rsrc3, s_save_buf_rsrc3, s_save_tmp //or MTYPE
s_mov_b32 s_save_m0, m0
/* global mem offset */
s_mov_b32 s_save_mem_offset, 0x0
s_getreg_b32 s_wave_size, hwreg(HW_REG_IB_STS2,SQ_WAVE_IB_STS2_WAVE64_SHIFT,SQ_WAVE_IB_STS2_WAVE64_SIZE)
s_lshl_b32 s_wave_size, s_wave_size, S_WAVE_SIZE
s_or_b32 s_wave_size, s_save_spi_init_hi, s_wave_size //share s_wave_size with exec_hi, it's at bit25
/* save HW registers */
L_SAVE_HWREG:
// HWREG SR memory offset : size(VGPR)+size(SVGPR)+size(SGPR)
get_vgpr_size_bytes(s_save_mem_offset, s_wave_size)
get_svgpr_size_bytes(s_save_tmp)
s_add_u32 s_save_mem_offset, s_save_mem_offset, s_save_tmp
s_add_u32 s_save_mem_offset, s_save_mem_offset, get_sgpr_size_bytes()
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
write_hwreg_to_mem(s_save_m0, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_pc_lo, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_pc_hi, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_exec_lo, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_exec_hi, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_status, s_save_buf_rsrc0, s_save_mem_offset)
s_getreg_b32 s_save_trapsts, hwreg(HW_REG_TRAPSTS)
write_hwreg_to_mem(s_save_trapsts, s_save_buf_rsrc0, s_save_mem_offset)
write_hwreg_to_mem(s_save_xnack_mask, s_save_buf_rsrc0, s_save_mem_offset)
s_getreg_b32 s_save_m0, hwreg(HW_REG_MODE)
write_hwreg_to_mem(s_save_m0, s_save_buf_rsrc0, s_save_mem_offset)
s_getreg_b32 s_save_m0, hwreg(HW_REG_SHADER_FLAT_SCRATCH_LO)
write_hwreg_to_mem(s_save_m0, s_save_buf_rsrc0, s_save_mem_offset)
s_getreg_b32 s_save_m0, hwreg(HW_REG_SHADER_FLAT_SCRATCH_HI)
write_hwreg_to_mem(s_save_m0, s_save_buf_rsrc0, s_save_mem_offset)
/* the first wave in the threadgroup */
s_and_b32 s_save_tmp, s_save_spi_init_hi, S_SAVE_SPI_INIT_FIRST_WAVE_MASK
s_mov_b32 s_save_exec_hi, 0x0
s_or_b32 s_save_exec_hi, s_save_tmp, s_save_exec_hi // save first wave bit to s_save_exec_hi.bits[26]
/* save SGPRs */
// Save SGPR before LDS save, then the s0 to s4 can be used during LDS save...
// SGPR SR memory offset : size(VGPR)+size(SVGPR)
get_vgpr_size_bytes(s_save_mem_offset, s_wave_size)
get_svgpr_size_bytes(s_save_tmp)
s_add_u32 s_save_mem_offset, s_save_mem_offset, s_save_tmp
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// backup s_save_buf_rsrc0,1 to s_save_pc_lo/hi, since write_16sgpr_to_mem function will change the rsrc0
s_mov_b32 s_save_xnack_mask, s_save_buf_rsrc0
s_add_u32 s_save_buf_rsrc0, s_save_buf_rsrc0, s_save_mem_offset
s_addc_u32 s_save_buf_rsrc1, s_save_buf_rsrc1, 0
s_mov_b32 m0, 0x0 //SGPR initial index value =0
s_nop 0x0 //Manually inserted wait states
L_SAVE_SGPR_LOOP:
// SGPR is allocated in 16 SGPR granularity
s_movrels_b64 s0, s0 //s0 = s[0+m0], s1 = s[1+m0]
s_movrels_b64 s2, s2 //s2 = s[2+m0], s3 = s[3+m0]
s_movrels_b64 s4, s4 //s4 = s[4+m0], s5 = s[5+m0]
s_movrels_b64 s6, s6 //s6 = s[6+m0], s7 = s[7+m0]
s_movrels_b64 s8, s8 //s8 = s[8+m0], s9 = s[9+m0]
s_movrels_b64 s10, s10 //s10 = s[10+m0], s11 = s[11+m0]
s_movrels_b64 s12, s12 //s12 = s[12+m0], s13 = s[13+m0]
s_movrels_b64 s14, s14 //s14 = s[14+m0], s15 = s[15+m0]
write_16sgpr_to_mem(s0, s_save_buf_rsrc0, s_save_mem_offset)
s_add_u32 m0, m0, 16 //next sgpr index
s_cmp_lt_u32 m0, 96 //scc = (m0 < first 96 SGPR) ? 1 : 0
s_cbranch_scc1 L_SAVE_SGPR_LOOP //first 96 SGPR save is complete?
//save the rest 12 SGPR
s_movrels_b64 s0, s0 //s0 = s[0+m0], s1 = s[1+m0]
s_movrels_b64 s2, s2 //s2 = s[2+m0], s3 = s[3+m0]
s_movrels_b64 s4, s4 //s4 = s[4+m0], s5 = s[5+m0]
s_movrels_b64 s6, s6 //s6 = s[6+m0], s7 = s[7+m0]
s_movrels_b64 s8, s8 //s8 = s[8+m0], s9 = s[9+m0]
s_movrels_b64 s10, s10 //s10 = s[10+m0], s11 = s[11+m0]
write_12sgpr_to_mem(s0, s_save_buf_rsrc0, s_save_mem_offset)
// restore s_save_buf_rsrc0,1
s_mov_b32 s_save_buf_rsrc0, s_save_xnack_mask
/* save first 4 VGPR, then LDS save could use */
// each wave will alloc 4 vgprs at least...
s_mov_b32 s_save_mem_offset, 0
s_mov_b32 exec_lo, 0xFFFFFFFF //need every thread from now on
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_SAVE_4VGPR_EXEC_HI
s_mov_b32 exec_hi, 0x00000000
s_branch L_SAVE_4VGPR_WAVE32
L_ENABLE_SAVE_4VGPR_EXEC_HI:
s_mov_b32 exec_hi, 0xFFFFFFFF
s_branch L_SAVE_4VGPR_WAVE64
L_SAVE_4VGPR_WAVE32:
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR Allocated in 4-GPR granularity
buffer_store_dword v0, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128
buffer_store_dword v2, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128*2
buffer_store_dword v3, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128*3
s_branch L_SAVE_LDS
L_SAVE_4VGPR_WAVE64:
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR Allocated in 4-GPR granularity
buffer_store_dword v0, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256
buffer_store_dword v2, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256*2
buffer_store_dword v3, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256*3
/* save LDS */
L_SAVE_LDS:
// Change EXEC to all threads...
s_mov_b32 exec_lo, 0xFFFFFFFF //need every thread from now on
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_SAVE_LDS_EXEC_HI
s_mov_b32 exec_hi, 0x00000000
s_branch L_SAVE_LDS_NORMAL
L_ENABLE_SAVE_LDS_EXEC_HI:
s_mov_b32 exec_hi, 0xFFFFFFFF
L_SAVE_LDS_NORMAL:
s_getreg_b32 s_save_alloc_size, hwreg(HW_REG_LDS_ALLOC,SQ_WAVE_LDS_ALLOC_LDS_SIZE_SHIFT,SQ_WAVE_LDS_ALLOC_LDS_SIZE_SIZE)
s_and_b32 s_save_alloc_size, s_save_alloc_size, 0xFFFFFFFF //lds_size is zero?
s_cbranch_scc0 L_SAVE_LDS_DONE //no lds used? jump to L_SAVE_DONE
s_barrier //LDS is used? wait for other waves in the same TG
s_and_b32 s_save_tmp, s_save_exec_hi, S_SAVE_SPI_INIT_FIRST_WAVE_MASK
s_cbranch_scc0 L_SAVE_LDS_DONE
// first wave do LDS save;
s_lshl_b32 s_save_alloc_size, s_save_alloc_size, 6 //LDS size in dwords = lds_size * 64dw
s_lshl_b32 s_save_alloc_size, s_save_alloc_size, 2 //LDS size in bytes
s_mov_b32 s_save_buf_rsrc2, s_save_alloc_size //NUM_RECORDS in bytes
// LDS at offset: size(VGPR)+size(SVGPR)+SIZE(SGPR)+SIZE(HWREG)
//
get_vgpr_size_bytes(s_save_mem_offset, s_wave_size)
get_svgpr_size_bytes(s_save_tmp)
s_add_u32 s_save_mem_offset, s_save_mem_offset, s_save_tmp
s_add_u32 s_save_mem_offset, s_save_mem_offset, get_sgpr_size_bytes()
s_add_u32 s_save_mem_offset, s_save_mem_offset, get_hwreg_size_bytes()
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
//load 0~63*4(byte address) to vgpr v0
v_mbcnt_lo_u32_b32 v0, -1, 0
v_mbcnt_hi_u32_b32 v0, -1, v0
v_mul_u32_u24 v0, 4, v0
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_mov_b32 m0, 0x0
s_cbranch_scc1 L_SAVE_LDS_W64
L_SAVE_LDS_W32:
s_mov_b32 s3, 128
s_nop 0
s_nop 0
s_nop 0
L_SAVE_LDS_LOOP_W32:
ds_read_b32 v1, v0
s_waitcnt 0
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
s_add_u32 m0, m0, s3 //every buffer_store_lds does 256 bytes
s_add_u32 s_save_mem_offset, s_save_mem_offset, s3
v_add_nc_u32 v0, v0, 128 //mem offset increased by 128 bytes
s_cmp_lt_u32 m0, s_save_alloc_size //scc=(m0 < s_save_alloc_size) ? 1 : 0
s_cbranch_scc1 L_SAVE_LDS_LOOP_W32 //LDS save is complete?
s_branch L_SAVE_LDS_DONE
L_SAVE_LDS_W64:
s_mov_b32 s3, 256
s_nop 0
s_nop 0
s_nop 0
L_SAVE_LDS_LOOP_W64:
ds_read_b32 v1, v0
s_waitcnt 0
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
s_add_u32 m0, m0, s3 //every buffer_store_lds does 256 bytes
s_add_u32 s_save_mem_offset, s_save_mem_offset, s3
v_add_nc_u32 v0, v0, 256 //mem offset increased by 256 bytes
s_cmp_lt_u32 m0, s_save_alloc_size //scc=(m0 < s_save_alloc_size) ? 1 : 0
s_cbranch_scc1 L_SAVE_LDS_LOOP_W64 //LDS save is complete?
L_SAVE_LDS_DONE:
/* save VGPRs - set the Rest VGPRs */
L_SAVE_VGPR:
// VGPR SR memory offset: 0
s_mov_b32 exec_lo, 0xFFFFFFFF //need every thread from now on
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_SAVE_VGPR_EXEC_HI
s_mov_b32 s_save_mem_offset, (0+128*4) // for the rest VGPRs
s_mov_b32 exec_hi, 0x00000000
s_branch L_SAVE_VGPR_NORMAL
L_ENABLE_SAVE_VGPR_EXEC_HI:
s_mov_b32 s_save_mem_offset, (0+256*4) // for the rest VGPRs
s_mov_b32 exec_hi, 0xFFFFFFFF
L_SAVE_VGPR_NORMAL:
s_getreg_b32 s_save_alloc_size, hwreg(HW_REG_GPR_ALLOC,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SHIFT,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SIZE)
s_add_u32 s_save_alloc_size, s_save_alloc_size, 1
s_lshl_b32 s_save_alloc_size, s_save_alloc_size, 2 //Number of VGPRs = (vgpr_size + 1) * 4 (non-zero value)
//determine it is wave32 or wave64
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_SAVE_VGPR_WAVE64
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR Allocated in 4-GPR granularity
// VGPR store using dw burst
s_mov_b32 m0, 0x4 //VGPR initial index value =4
s_cmp_lt_u32 m0, s_save_alloc_size
s_cbranch_scc0 L_SAVE_VGPR_END
L_SAVE_VGPR_W32_LOOP:
v_movrels_b32 v0, v0 //v0 = v[0+m0]
v_movrels_b32 v1, v1 //v1 = v[1+m0]
v_movrels_b32 v2, v2 //v2 = v[2+m0]
v_movrels_b32 v3, v3 //v3 = v[3+m0]
buffer_store_dword v0, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128
buffer_store_dword v2, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128*2
buffer_store_dword v3, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:128*3
s_add_u32 m0, m0, 4 //next vgpr index
s_add_u32 s_save_mem_offset, s_save_mem_offset, 128*4 //every buffer_store_dword does 128 bytes
s_cmp_lt_u32 m0, s_save_alloc_size //scc = (m0 < s_save_alloc_size) ? 1 : 0
s_cbranch_scc1 L_SAVE_VGPR_W32_LOOP //VGPR save is complete?
s_branch L_SAVE_VGPR_END
L_SAVE_VGPR_WAVE64:
s_mov_b32 s_save_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR store using dw burst
s_mov_b32 m0, 0x4 //VGPR initial index value =4
s_cmp_lt_u32 m0, s_save_alloc_size
s_cbranch_scc0 L_SAVE_VGPR_END
L_SAVE_VGPR_W64_LOOP:
v_movrels_b32 v0, v0 //v0 = v[0+m0]
v_movrels_b32 v1, v1 //v1 = v[1+m0]
v_movrels_b32 v2, v2 //v2 = v[2+m0]
v_movrels_b32 v3, v3 //v3 = v[3+m0]
buffer_store_dword v0, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
buffer_store_dword v1, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256
buffer_store_dword v2, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256*2
buffer_store_dword v3, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1 offset:256*3
s_add_u32 m0, m0, 4 //next vgpr index
s_add_u32 s_save_mem_offset, s_save_mem_offset, 256*4 //every buffer_store_dword does 256 bytes
s_cmp_lt_u32 m0, s_save_alloc_size //scc = (m0 < s_save_alloc_size) ? 1 : 0
s_cbranch_scc1 L_SAVE_VGPR_W64_LOOP //VGPR save is complete?
//Below part will be the save shared vgpr part (new for gfx10)
s_getreg_b32 s_save_alloc_size, hwreg(HW_REG_LDS_ALLOC,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SHIFT,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SIZE)
s_and_b32 s_save_alloc_size, s_save_alloc_size, 0xFFFFFFFF //shared_vgpr_size is zero?
s_cbranch_scc0 L_SAVE_VGPR_END //no shared_vgpr used? jump to L_SAVE_LDS
s_lshl_b32 s_save_alloc_size, s_save_alloc_size, 3 //Number of SHARED_VGPRs = shared_vgpr_size * 8 (non-zero value)
//m0 now has the value of normal vgpr count, just add the m0 with shared_vgpr count to get the total count.
//save shared_vgpr will start from the index of m0
s_add_u32 s_save_alloc_size, s_save_alloc_size, m0
s_mov_b32 exec_lo, 0xFFFFFFFF
s_mov_b32 exec_hi, 0x00000000
L_SAVE_SHARED_VGPR_WAVE64_LOOP:
v_movrels_b32 v0, v0 //v0 = v[0+m0]
buffer_store_dword v0, v0, s_save_buf_rsrc0, s_save_mem_offset slc:1 glc:1
s_add_u32 m0, m0, 1 //next vgpr index
s_add_u32 s_save_mem_offset, s_save_mem_offset, 128
s_cmp_lt_u32 m0, s_save_alloc_size //scc = (m0 < s_save_alloc_size) ? 1 : 0
s_cbranch_scc1 L_SAVE_SHARED_VGPR_WAVE64_LOOP //SHARED_VGPR save is complete?
L_SAVE_VGPR_END:
s_branch L_END_PGM
L_RESTORE:
/* Setup Resource Contants */
s_mov_b32 s_restore_buf_rsrc0, s_restore_spi_init_lo //base_addr_lo
s_and_b32 s_restore_buf_rsrc1, s_restore_spi_init_hi, 0x0000FFFF //base_addr_hi
s_or_b32 s_restore_buf_rsrc1, s_restore_buf_rsrc1, S_RESTORE_BUF_RSRC_WORD1_STRIDE
s_mov_b32 s_restore_buf_rsrc2, 0 //NUM_RECORDS initial value = 0 (in bytes)
s_mov_b32 s_restore_buf_rsrc3, S_RESTORE_BUF_RSRC_WORD3_MISC
s_and_b32 s_restore_tmp, s_restore_spi_init_hi, S_RESTORE_SPI_INIT_ATC_MASK
s_lshr_b32 s_restore_tmp, s_restore_tmp, (S_RESTORE_SPI_INIT_ATC_SHIFT-SQ_BUF_RSRC_WORD1_ATC_SHIFT)
s_or_b32 s_restore_buf_rsrc3, s_restore_buf_rsrc3, s_restore_tmp //or ATC
s_and_b32 s_restore_tmp, s_restore_spi_init_hi, S_RESTORE_SPI_INIT_MTYPE_MASK
s_lshr_b32 s_restore_tmp, s_restore_tmp, (S_RESTORE_SPI_INIT_MTYPE_SHIFT-SQ_BUF_RSRC_WORD3_MTYPE_SHIFT)
s_or_b32 s_restore_buf_rsrc3, s_restore_buf_rsrc3, s_restore_tmp //or MTYPE
//determine it is wave32 or wave64
s_getreg_b32 s_restore_size, hwreg(HW_REG_IB_STS2,SQ_WAVE_IB_STS2_WAVE64_SHIFT,SQ_WAVE_IB_STS2_WAVE64_SIZE)
s_lshl_b32 s_restore_size, s_restore_size, S_WAVE_SIZE
s_or_b32 s_restore_size, s_restore_spi_init_hi, s_restore_size
s_and_b32 s_restore_tmp, s_restore_spi_init_hi, S_RESTORE_SPI_INIT_FIRST_WAVE_MASK
s_cbranch_scc0 L_RESTORE_VGPR
/* restore LDS */
L_RESTORE_LDS:
s_mov_b32 exec_lo, 0xFFFFFFFF //need every thread from now on
s_lshr_b32 m0, s_restore_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_RESTORE_LDS_EXEC_HI
s_mov_b32 exec_hi, 0x00000000
s_branch L_RESTORE_LDS_NORMAL
L_ENABLE_RESTORE_LDS_EXEC_HI:
s_mov_b32 exec_hi, 0xFFFFFFFF
L_RESTORE_LDS_NORMAL:
s_getreg_b32 s_restore_alloc_size, hwreg(HW_REG_LDS_ALLOC,SQ_WAVE_LDS_ALLOC_LDS_SIZE_SHIFT,SQ_WAVE_LDS_ALLOC_LDS_SIZE_SIZE)
s_and_b32 s_restore_alloc_size, s_restore_alloc_size, 0xFFFFFFFF //lds_size is zero?
s_cbranch_scc0 L_RESTORE_VGPR //no lds used? jump to L_RESTORE_VGPR
s_lshl_b32 s_restore_alloc_size, s_restore_alloc_size, 6 //LDS size in dwords = lds_size * 64dw
s_lshl_b32 s_restore_alloc_size, s_restore_alloc_size, 2 //LDS size in bytes
s_mov_b32 s_restore_buf_rsrc2, s_restore_alloc_size //NUM_RECORDS in bytes
// LDS at offset: size(VGPR)+size(SVGPR)+SIZE(SGPR)+SIZE(HWREG)
//
get_vgpr_size_bytes(s_restore_mem_offset, s_restore_size)
get_svgpr_size_bytes(s_restore_tmp)
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, s_restore_tmp
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, get_sgpr_size_bytes()
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, get_hwreg_size_bytes()
s_mov_b32 s_restore_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
s_lshr_b32 m0, s_wave_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_mov_b32 m0, 0x0
s_cbranch_scc1 L_RESTORE_LDS_LOOP_W64
L_RESTORE_LDS_LOOP_W32:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset lds:1 // first 64DW
s_add_u32 m0, m0, 128 // 128 DW
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 128 //mem offset increased by 128DW
s_cmp_lt_u32 m0, s_restore_alloc_size //scc=(m0 < s_restore_alloc_size) ? 1 : 0
s_cbranch_scc1 L_RESTORE_LDS_LOOP_W32 //LDS restore is complete?
s_branch L_RESTORE_VGPR
L_RESTORE_LDS_LOOP_W64:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset lds:1 // first 64DW
s_add_u32 m0, m0, 256 // 256 DW
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 256 //mem offset increased by 256DW
s_cmp_lt_u32 m0, s_restore_alloc_size //scc=(m0 < s_restore_alloc_size) ? 1 : 0
s_cbranch_scc1 L_RESTORE_LDS_LOOP_W64 //LDS restore is complete?
/* restore VGPRs */
L_RESTORE_VGPR:
// VGPR SR memory offset : 0
s_mov_b32 s_restore_mem_offset, 0x0
s_mov_b32 exec_lo, 0xFFFFFFFF //need every thread from now on
s_lshr_b32 m0, s_restore_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_RESTORE_VGPR_EXEC_HI
s_mov_b32 exec_hi, 0x00000000
s_branch L_RESTORE_VGPR_NORMAL
L_ENABLE_RESTORE_VGPR_EXEC_HI:
s_mov_b32 exec_hi, 0xFFFFFFFF
L_RESTORE_VGPR_NORMAL:
s_getreg_b32 s_restore_alloc_size, hwreg(HW_REG_GPR_ALLOC,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SHIFT,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SIZE)
s_add_u32 s_restore_alloc_size, s_restore_alloc_size, 1
s_lshl_b32 s_restore_alloc_size, s_restore_alloc_size, 2 //Number of VGPRs = (vgpr_size + 1) * 4 (non-zero value)
//determine it is wave32 or wave64
s_lshr_b32 m0, s_restore_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_RESTORE_VGPR_WAVE64
s_mov_b32 s_restore_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR load using dw burst
s_mov_b32 s_restore_mem_offset_save, s_restore_mem_offset // restore start with v1, v0 will be the last
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 128*4
s_mov_b32 m0, 4 //VGPR initial index value = 4
L_RESTORE_VGPR_WAVE32_LOOP:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1
buffer_load_dword v1, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:128
buffer_load_dword v2, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:128*2
buffer_load_dword v3, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:128*3
s_waitcnt vmcnt(0)
v_movreld_b32 v0, v0 //v[0+m0] = v0
v_movreld_b32 v1, v1
v_movreld_b32 v2, v2
v_movreld_b32 v3, v3
s_add_u32 m0, m0, 4 //next vgpr index
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 128*4 //every buffer_load_dword does 128 bytes
s_cmp_lt_u32 m0, s_restore_alloc_size //scc = (m0 < s_restore_alloc_size) ? 1 : 0
s_cbranch_scc1 L_RESTORE_VGPR_WAVE32_LOOP //VGPR restore (except v0) is complete?
/* VGPR restore on v0 */
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1
buffer_load_dword v1, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:128
buffer_load_dword v2, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:128*2
buffer_load_dword v3, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:128*3
s_branch L_RESTORE_SGPR
L_RESTORE_VGPR_WAVE64:
s_mov_b32 s_restore_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
// VGPR load using dw burst
s_mov_b32 s_restore_mem_offset_save, s_restore_mem_offset // restore start with v4, v0 will be the last
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 256*4
s_mov_b32 m0, 4 //VGPR initial index value = 4
L_RESTORE_VGPR_WAVE64_LOOP:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1
buffer_load_dword v1, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:256
buffer_load_dword v2, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:256*2
buffer_load_dword v3, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1 offset:256*3
s_waitcnt vmcnt(0)
v_movreld_b32 v0, v0 //v[0+m0] = v0
v_movreld_b32 v1, v1
v_movreld_b32 v2, v2
v_movreld_b32 v3, v3
s_add_u32 m0, m0, 4 //next vgpr index
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 256*4 //every buffer_load_dword does 256 bytes
s_cmp_lt_u32 m0, s_restore_alloc_size //scc = (m0 < s_restore_alloc_size) ? 1 : 0
s_cbranch_scc1 L_RESTORE_VGPR_WAVE64_LOOP //VGPR restore (except v0) is complete?
//Below part will be the restore shared vgpr part (new for gfx10)
s_getreg_b32 s_restore_alloc_size, hwreg(HW_REG_LDS_ALLOC,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SHIFT,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SIZE) //shared_vgpr_size
s_and_b32 s_restore_alloc_size, s_restore_alloc_size, 0xFFFFFFFF //shared_vgpr_size is zero?
s_cbranch_scc0 L_RESTORE_V0 //no shared_vgpr used?
s_lshl_b32 s_restore_alloc_size, s_restore_alloc_size, 3 //Number of SHARED_VGPRs = shared_vgpr_size * 8 (non-zero value)
//m0 now has the value of normal vgpr count, just add the m0 with shared_vgpr count to get the total count.
//restore shared_vgpr will start from the index of m0
s_add_u32 s_restore_alloc_size, s_restore_alloc_size, m0
s_mov_b32 exec_lo, 0xFFFFFFFF
s_mov_b32 exec_hi, 0x00000000
L_RESTORE_SHARED_VGPR_WAVE64_LOOP:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset slc:1 glc:1
s_waitcnt vmcnt(0)
v_movreld_b32 v0, v0 //v[0+m0] = v0
s_add_u32 m0, m0, 1 //next vgpr index
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, 128
s_cmp_lt_u32 m0, s_restore_alloc_size //scc = (m0 < s_restore_alloc_size) ? 1 : 0
s_cbranch_scc1 L_RESTORE_SHARED_VGPR_WAVE64_LOOP //VGPR restore (except v0) is complete?
s_mov_b32 exec_hi, 0xFFFFFFFF //restore back exec_hi before restoring V0!!
/* VGPR restore on v0 */
L_RESTORE_V0:
buffer_load_dword v0, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1
buffer_load_dword v1, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:256
buffer_load_dword v2, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:256*2
buffer_load_dword v3, v0, s_restore_buf_rsrc0, s_restore_mem_offset_save slc:1 glc:1 offset:256*3
/* restore SGPRs */
//will be 2+8+16*6
// SGPR SR memory offset : size(VGPR)+size(SVGPR)
L_RESTORE_SGPR:
get_vgpr_size_bytes(s_restore_mem_offset, s_restore_size)
get_svgpr_size_bytes(s_restore_tmp)
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, s_restore_tmp
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, get_sgpr_size_bytes()
s_sub_u32 s_restore_mem_offset, s_restore_mem_offset, 20*4 //s108~s127 is not saved
s_mov_b32 s_restore_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
s_mov_b32 m0, s_sgpr_save_num
read_4sgpr_from_mem(s0, s_restore_buf_rsrc0, s_restore_mem_offset)
s_waitcnt lgkmcnt(0)
s_sub_u32 m0, m0, 4 // Restore from S[0] to S[104]
s_nop 0 // hazard SALU M0=> S_MOVREL
s_movreld_b64 s0, s0 //s[0+m0] = s0
s_movreld_b64 s2, s2
read_8sgpr_from_mem(s0, s_restore_buf_rsrc0, s_restore_mem_offset)
s_waitcnt lgkmcnt(0)
s_sub_u32 m0, m0, 8 // Restore from S[0] to S[96]
s_nop 0 // hazard SALU M0=> S_MOVREL
s_movreld_b64 s0, s0 //s[0+m0] = s0
s_movreld_b64 s2, s2
s_movreld_b64 s4, s4
s_movreld_b64 s6, s6
L_RESTORE_SGPR_LOOP:
read_16sgpr_from_mem(s0, s_restore_buf_rsrc0, s_restore_mem_offset)
s_waitcnt lgkmcnt(0)
s_sub_u32 m0, m0, 16 // Restore from S[n] to S[0]
s_nop 0 // hazard SALU M0=> S_MOVREL
s_movreld_b64 s0, s0 //s[0+m0] = s0
s_movreld_b64 s2, s2
s_movreld_b64 s4, s4
s_movreld_b64 s6, s6
s_movreld_b64 s8, s8
s_movreld_b64 s10, s10
s_movreld_b64 s12, s12
s_movreld_b64 s14, s14
s_cmp_eq_u32 m0, 0 //scc = (m0 < s_sgpr_save_num) ? 1 : 0
s_cbranch_scc0 L_RESTORE_SGPR_LOOP
/* restore HW registers */
L_RESTORE_HWREG:
// HWREG SR memory offset : size(VGPR)+size(SVGPR)+size(SGPR)
get_vgpr_size_bytes(s_restore_mem_offset, s_restore_size)
get_svgpr_size_bytes(s_restore_tmp)
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, s_restore_tmp
s_add_u32 s_restore_mem_offset, s_restore_mem_offset, get_sgpr_size_bytes()
s_mov_b32 s_restore_buf_rsrc2, 0x1000000 //NUM_RECORDS in bytes
read_hwreg_from_mem(s_restore_m0, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_pc_lo, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_pc_hi, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_exec_lo, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_exec_hi, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_status, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_trapsts, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_xnack_mask, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_mode, s_restore_buf_rsrc0, s_restore_mem_offset)
read_hwreg_from_mem(s_restore_flat_scratch, s_restore_buf_rsrc0, s_restore_mem_offset)
s_waitcnt lgkmcnt(0)
s_setreg_b32 hwreg(HW_REG_SHADER_FLAT_SCRATCH_LO), s_restore_flat_scratch
read_hwreg_from_mem(s_restore_flat_scratch, s_restore_buf_rsrc0, s_restore_mem_offset)
s_waitcnt lgkmcnt(0) //from now on, it is safe to restore STATUS and IB_STS
s_setreg_b32 hwreg(HW_REG_SHADER_FLAT_SCRATCH_HI), s_restore_flat_scratch
s_mov_b32 s_restore_tmp, s_restore_pc_hi
s_and_b32 s_restore_pc_hi, s_restore_tmp, 0x0000ffff //pc[47:32] //Do it here in order not to affect STATUS
s_mov_b32 m0, s_restore_m0
s_mov_b32 exec_lo, s_restore_exec_lo
s_mov_b32 exec_hi, s_restore_exec_hi
s_and_b32 s_restore_m0, SQ_WAVE_TRAPSTS_PRE_SAVECTX_MASK, s_restore_trapsts
s_setreg_b32 hwreg(HW_REG_TRAPSTS, SQ_WAVE_TRAPSTS_PRE_SAVECTX_SHIFT, SQ_WAVE_TRAPSTS_PRE_SAVECTX_SIZE), s_restore_m0
s_setreg_b32 hwreg(HW_REG_SHADER_XNACK_MASK), s_restore_xnack_mask
s_and_b32 s_restore_m0, SQ_WAVE_TRAPSTS_POST_SAVECTX_MASK, s_restore_trapsts
s_lshr_b32 s_restore_m0, s_restore_m0, SQ_WAVE_TRAPSTS_POST_SAVECTX_SHIFT
s_setreg_b32 hwreg(HW_REG_TRAPSTS, SQ_WAVE_TRAPSTS_POST_SAVECTX_SHIFT, SQ_WAVE_TRAPSTS_POST_SAVECTX_SIZE), s_restore_m0
s_setreg_b32 hwreg(HW_REG_MODE), s_restore_mode
s_and_b32 s_restore_m0, s_restore_tmp, S_SAVE_PC_HI_RCNT_MASK
s_lshr_b32 s_restore_m0, s_restore_m0, S_SAVE_PC_HI_RCNT_SHIFT
s_lshl_b32 s_restore_m0, s_restore_m0, SQ_WAVE_IB_STS_RCNT_SHIFT
s_mov_b32 s_restore_mode, 0x0
s_or_b32 s_restore_mode, s_restore_mode, s_restore_m0
s_and_b32 s_restore_m0, s_restore_tmp, S_SAVE_PC_HI_FIRST_REPLAY_MASK
s_lshr_b32 s_restore_m0, s_restore_m0, S_SAVE_PC_HI_FIRST_REPLAY_SHIFT
s_lshl_b32 s_restore_m0, s_restore_m0, SQ_WAVE_IB_STS_FIRST_REPLAY_SHIFT
s_or_b32 s_restore_mode, s_restore_mode, s_restore_m0
s_and_b32 s_restore_m0, s_restore_tmp, S_SAVE_PC_HI_REPLAY_W64H_MASK
s_lshr_b32 s_restore_m0, s_restore_m0, S_SAVE_PC_HI_REPLAY_W64H_SHIFT
s_lshl_b32 s_restore_m0, s_restore_m0, SQ_WAVE_IB_STS_REPLAY_W64H_SHIFT
s_or_b32 s_restore_mode, s_restore_mode, s_restore_m0
s_and_b32 s_restore_m0, s_restore_status, SQ_WAVE_STATUS_INST_ATC_MASK
s_lshr_b32 s_restore_m0, s_restore_m0, SQ_WAVE_STATUS_INST_ATC_SHIFT
s_setreg_b32 hwreg(HW_REG_IB_STS), s_restore_mode
s_and_b64 exec, exec, exec // Restore STATUS.EXECZ, not writable by s_setreg_b32
s_and_b64 vcc, vcc, vcc // Restore STATUS.VCCZ, not writable by s_setreg_b32
s_setreg_b32 hwreg(HW_REG_STATUS), s_restore_status // SCC is included, which is changed by previous salu
s_barrier //barrier to ensure the readiness of LDS before access attemps from any other wave in the same TG
s_rfe_b64 s_restore_pc_lo //Return to the main shader program and resume execution
L_END_PGM:
s_endpgm
end
function write_hwreg_to_mem(s, s_rsrc, s_mem_offset)
s_mov_b32 exec_lo, m0
s_mov_b32 m0, s_mem_offset
s_buffer_store_dword s, s_rsrc, m0 glc:1
s_add_u32 s_mem_offset, s_mem_offset, 4
s_mov_b32 m0, exec_lo
end
function write_16sgpr_to_mem(s, s_rsrc, s_mem_offset)
s_buffer_store_dwordx4 s[0], s_rsrc, 0 glc:1
s_buffer_store_dwordx4 s[4], s_rsrc, 16 glc:1
s_buffer_store_dwordx4 s[8], s_rsrc, 32 glc:1
s_buffer_store_dwordx4 s[12], s_rsrc, 48 glc:1
s_add_u32 s_rsrc[0], s_rsrc[0], 4*16
s_addc_u32 s_rsrc[1], s_rsrc[1], 0x0
end
function write_12sgpr_to_mem(s, s_rsrc, s_mem_offset)
s_buffer_store_dwordx4 s[0], s_rsrc, 0 glc:1
s_buffer_store_dwordx4 s[4], s_rsrc, 16 glc:1
s_buffer_store_dwordx4 s[8], s_rsrc, 32 glc:1
s_add_u32 s_rsrc[0], s_rsrc[0], 4*12
s_addc_u32 s_rsrc[1], s_rsrc[1], 0x0
end
function read_hwreg_from_mem(s, s_rsrc, s_mem_offset)
s_buffer_load_dword s, s_rsrc, s_mem_offset glc:1
s_add_u32 s_mem_offset, s_mem_offset, 4
end
function read_16sgpr_from_mem(s, s_rsrc, s_mem_offset)
s_sub_u32 s_mem_offset, s_mem_offset, 4*16
s_buffer_load_dwordx16 s, s_rsrc, s_mem_offset glc:1
end
function read_8sgpr_from_mem(s, s_rsrc, s_mem_offset)
s_sub_u32 s_mem_offset, s_mem_offset, 4*8
s_buffer_load_dwordx8 s, s_rsrc, s_mem_offset glc:1
end
function read_4sgpr_from_mem(s, s_rsrc, s_mem_offset)
s_sub_u32 s_mem_offset, s_mem_offset, 4*4
s_buffer_load_dwordx4 s, s_rsrc, s_mem_offset glc:1
end
function get_lds_size_bytes(s_lds_size_byte)
s_getreg_b32 s_lds_size_byte, hwreg(HW_REG_LDS_ALLOC, SQ_WAVE_LDS_ALLOC_LDS_SIZE_SHIFT, SQ_WAVE_LDS_ALLOC_LDS_SIZE_SIZE)
s_lshl_b32 s_lds_size_byte, s_lds_size_byte, 8 //LDS size in dwords = lds_size * 64 *4Bytes // granularity 64DW
end
function get_vgpr_size_bytes(s_vgpr_size_byte, s_size)
s_getreg_b32 s_vgpr_size_byte, hwreg(HW_REG_GPR_ALLOC,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SHIFT,SQ_WAVE_GPR_ALLOC_VGPR_SIZE_SIZE)
s_add_u32 s_vgpr_size_byte, s_vgpr_size_byte, 1
s_lshr_b32 m0, s_size, S_WAVE_SIZE
s_and_b32 m0, m0, 1
s_cmp_eq_u32 m0, 1
s_cbranch_scc1 L_ENABLE_SHIFT_W64
s_lshl_b32 s_vgpr_size_byte, s_vgpr_size_byte, (2+7) //Number of VGPRs = (vgpr_size + 1) * 4 * 32 * 4 (non-zero value)
s_branch L_SHIFT_DONE
L_ENABLE_SHIFT_W64:
s_lshl_b32 s_vgpr_size_byte, s_vgpr_size_byte, (2+8) //Number of VGPRs = (vgpr_size + 1) * 4 * 64 * 4 (non-zero value)
L_SHIFT_DONE:
end
function get_svgpr_size_bytes(s_svgpr_size_byte)
s_getreg_b32 s_svgpr_size_byte, hwreg(HW_REG_LDS_ALLOC,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SHIFT,SQ_WAVE_LDS_ALLOC_VGPR_SHARED_SIZE_SIZE)
s_lshl_b32 s_svgpr_size_byte, s_svgpr_size_byte, (3+7)
end
function get_sgpr_size_bytes
return 512
end
function get_hwreg_size_bytes
return 128
end
",16341,True,3331.7408890996808,median
"/*
SelectionList.ino
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#ifdef U8X8_HAVE_HW_SPI
#include
#endif
#ifdef U8X8_HAVE_HW_I2C
#include
#endif
/*
U8glib Example Overview:
Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
*/
// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0); // null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6); // Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE); // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17); // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1108_160X160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.69"" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_EA_W128128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_EA_W128128_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_EA_W128128_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1327_MIDAS_128X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_ADAFRUIT_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_ADAFRUIT_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1317_96X96_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1317_96X96_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8); // SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE); // NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_HX1230_96X68_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */); // Remember to set R/W to 0
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_JLX12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064I_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_ENH_DG128064I_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_64X32_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST75256_JLX172104_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X64_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/ A4); // Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_160X80_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EW50850_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1638_160X128_F_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); // Not tested
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Good Display
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
//U8G2_MAX7219_32X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_MAX7219_8X8_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE);
//U8G2_LS013B7DH03_128X128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8); // there is no DC line for this display
//U8G2_LS027B7DH01_400X240_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8); // there is no DC line for this display
// End of constructor list
void setup(void) {
// DOGS102 Shield (http://shieldlist.org/controlconnection/dogs102)
// u8g2.begin(/* menu_select_pin= */ 5, /* menu_next_pin= */ 4, /* menu_prev_pin= */ 2, /* menu_home_pin= */ 3);
// DOGM128 Shield (http://shieldlist.org/schmelle2/dogm128) + DOGXL160 Shield
// u8g2.begin(/* menu_select_pin= */ 2, /* menu_next_pin= */ 3, /* menu_prev_pin= */ 7, /* menu_home_pin= */ 8);
// MKR Zero Test Board
//u8g2.begin(/*Select=*/ 0, /*Right/Next=*/ 1, /*Left/Prev=*/ 2, /*Up=*/ 4, /*Down=*/ 3, /*Home/Cancel=*/ A6);
// Arduboy
//u8g2.begin(/*Select=*/ A0, /*Right/Next=*/ 5, /*Left/Prev=*/ 9, /*Up=*/ 8, /*Down=*/ 10, /*Home/Cancel=*/ A1); // Arduboy DevKit
u8g2.begin(/*Select=*/ 7, /*Right/Next=*/ A1, /*Left/Prev=*/ A2, /*Up=*/ A0, /*Down=*/ A3, /*Home/Cancel=*/ 8); // Arduboy 10 (Production)
u8g2.setFont(u8g2_font_6x12_tr);
}
const char *string_list =
""Altocumulus\\n""
""Altostratus\\n""
""Cirrocumulus\\n""
""Cirrostratus\\n""
""Cirrus\\n""
""Cumulonimbus\\n""
""Cumulus\\n""
""Nimbostratus\\n""
""Stratocumulus\\n""
""Stratus"";
uint8_t current_selection = 0;
void loop(void) {
current_selection = u8g2.userInterfaceSelectionList(
""Cloud Types"",
current_selection,
string_list);
if ( current_selection == 0 ) {
u8g2.userInterfaceMessage(
""Nothing selected."",
"""",
"""",
"" ok "");
} else {
u8g2.userInterfaceMessage(
""Selection:"",
u8x8_GetStringLineStart(current_selection-1, string_list ),
"""",
"" ok \\n cancel "");
}
}
",12453,True,3702.805380724279,median
"/*
DirectAccess.ino
Demonstrate how to interact with the internal buffer directly
Warning: This example will not work with all graphics controller.
It will work with SSD13xx, UC1xxx, ST7656 controller
It will definitly not work with ST7920, T6962, RA8835.
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#ifdef U8X8_HAVE_HW_SPI
#include
#endif
#ifdef U8X8_HAVE_HW_I2C
#include
#endif
/*
U8glib Example Overview:
Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
This is a page buffer example.
*/
// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_NULL u8g2(U8G2_R0); // null device, a 8x8 pixel display which does nothing
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6); // Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE); // ESP32 Thing, pure SW emulated I2C
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17); // ESP32 Thing, HW I2C with pin remapping
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but may solve the ""every 2nd line skipped"" problem
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // same as the NONAME variant, but uses updated SH1106 init sequence
//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA); // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // EastRising 0.69"" OLED
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // experimental driver for ER-OLED018-1
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8); // SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE); // NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Could be also PCF8814
//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/ U8X8_PIN_NONE); // Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */); // Remember to set R/W to 0
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE); // DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Adafruit ST7565 GLCD
//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8); // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5); // MKR Zero, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Uno, Enable U8g2 16 bit mode for this display
//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, enable U8g2 16 bit mode for this display
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37, /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/ A4); // Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8); // Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_UC1638_160X128_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 2, /* dc=*/ 3, /* reset=*/ 4); // Not tested
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // eInk/ePaper Display, original LUT from embedded artists
//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // Good Display
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
// End of constructor list
uint8_t background_images[8][32];
void setup(void) {
uint8_t i;
/* U8g2 Project: SSD1306 Test Board */
//pinMode(10, OUTPUT);
//pinMode(9, OUTPUT);
//digitalWrite(10, 0);
//digitalWrite(9, 0);
/* U8g2 Project: T6963 Test Board */
//pinMode(18, OUTPUT);
//digitalWrite(18, 1);
u8g2.begin();
u8g2.setFlipMode(0);
u8g2.setFont(u8g2_font_chroma48medium8_8r);
u8g2.setFontPosBottom();
// create eight images for a background animation
for( i = 0; i < 8; i++ ) {
// setup buffer by starting with the first page
u8g2.firstPage();
// render some graphics into the buffer
u8g2.drawStr(0-i,8,""U8g2U"");
// store four tiles from the start of the buffer content in some local memory
// one tile has 8x8 pixel: 8 bytes, four tiles are 32 bytes.
// note: the actual memory pattern depends on the target display
memcpy(background_images[i], u8g2.getBufferPtr(), 32);
}
// revert back to basline pos
u8g2.setFontPosBaseline();
}
void drawBackground(uint8_t image_idx)
{
u8g2_uint_t src_idx, dest_idx, total;
uint8_t *buf;
total = u8g2.getBufferTileWidth();
total *= 8; // calculate width in pixel
// get the pointer to the buffer. We will write the image to that buffer
buf = u8g2.getBufferPtr();
// fill the buffer with the background image
// repeat the image until the complete width is filled
src_idx = 0;
for( dest_idx = 0; dest_idx < total; dest_idx++ )
{
buf[dest_idx] = background_images[image_idx][src_idx];
src_idx++;
if ( src_idx >= 32 )
src_idx = 0;
}
}
void drawLogo(void)
{
u8g2.setFontMode(1); // Transparent
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(0, 30, ""U"");
u8g2.setFontDirection(1);
u8g2.setFont(u8g2_font_inb30_mn);
u8g2.drawStr(21,8,""8"");
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(51,30,""g"");
u8g2.drawStr(67,30,""\\xb2"");
u8g2.drawHLine(2, 35, 47);
u8g2.drawHLine(3, 36, 47);
u8g2.drawVLine(45, 32, 12);
u8g2.drawVLine(46, 33, 12);
}
uint8_t image_idx = 0;
uint8_t dir = 0;
void loop(void) {
// buffer clear is not required any more
// this increase performance a little bit
u8g2.setAutoPageClear(0);
// draw the U8g2 logo with a custom background
u8g2.firstPage();
do {
drawBackground(image_idx);
drawLogo();
} while ( u8g2.nextPage() );
// move the background around
if ( dir == 0 ){
image_idx++;
if ( image_idx == 7 ) {
dir = 1;
}
} else {
image_idx--;
if ( image_idx == 0 ) {
dir = 0;
}
}
delay(10);
}
",12033,True,3393.6938828891844,median
"###############################################################################
# Copyright 2019 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material (""Material"") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# ""License""), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 5, 0x90
CONST_TABLE:
_poly:
.quad 0x1, 0xC200000000000000
_twoone:
.quad 0x1, 0x100000000
_u128_str:
.byte 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
_mask1:
.quad 0xffffffffffffffff, 0x0
_mask2:
.quad 0x0, 0xffffffffffffffff
_inc1:
.quad 1,0
.p2align 5, 0x90
.globl _g9_AesGcmPrecompute_avx
_g9_AesGcmPrecompute_avx:
push %ebp
mov %esp, %ebp
push %esi
call .L__0000gas_1
.L__0000gas_1:
pop %esi
sub $(.L__0000gas_1-CONST_TABLE), %esi
movl (8)(%ebp), %eax
movdqu (%eax), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm0
psrlq $(63), %xmm4
movdqa %xmm4, %xmm3
pslldq $(8), %xmm4
psrldq $(8), %xmm3
por %xmm4, %xmm0
pshufd $(36), %xmm3, %xmm4
pcmpeqd ((_twoone-CONST_TABLE))(%esi), %xmm4
pand ((_poly-CONST_TABLE))(%esi), %xmm4
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm1
pshufd $(78), %xmm1, %xmm5
pshufd $(78), %xmm0, %xmm3
pxor %xmm1, %xmm5
pxor %xmm0, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm1, %xmm4
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm0, %xmm4
pxor %xmm1, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm3
psllq $(1), %xmm3
pxor %xmm1, %xmm3
psllq $(5), %xmm3
pxor %xmm1, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm1
pxor %xmm3, %xmm4
movdqa %xmm1, %xmm5
psrlq $(5), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm1, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm1
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
pshufd $(78), %xmm2, %xmm5
pshufd $(78), %xmm1, %xmm3
pxor %xmm2, %xmm5
pxor %xmm1, %xmm3
pclmulqdq $(0), %xmm3, %xmm5
movdqa %xmm2, %xmm4
pclmulqdq $(0), %xmm1, %xmm2
pxor %xmm3, %xmm3
pclmulqdq $(17), %xmm1, %xmm4
pxor %xmm2, %xmm5
pxor %xmm4, %xmm5
palignr $(8), %xmm5, %xmm3
pslldq $(8), %xmm5
pxor %xmm3, %xmm4
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm3
psllq $(1), %xmm3
pxor %xmm2, %xmm3
psllq $(5), %xmm3
pxor %xmm2, %xmm3
psllq $(57), %xmm3
movdqa %xmm3, %xmm5
pslldq $(8), %xmm5
psrldq $(8), %xmm3
pxor %xmm5, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm2, %xmm5
psrlq $(5), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm2, %xmm5
psrlq $(1), %xmm5
pxor %xmm5, %xmm2
pxor %xmm4, %xmm2
movl (12)(%ebp), %eax
movdqu %xmm0, (%eax)
movdqu %xmm1, (16)(%eax)
movdqu %xmm2, (32)(%eax)
pop %esi
pop %ebp
ret
.p2align 5, 0x90
.globl _g9_AesGcmMulGcm_avx
_g9_AesGcmMulGcm_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
call .L__0001gas_2
.L__0001gas_2:
pop %esi
sub $(.L__0001gas_2-CONST_TABLE), %esi
movl (8)(%ebp), %edi
movl (12)(%ebp), %eax
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.p2align 5, 0x90
.globl _g9_AesGcmAuth_avx
_g9_AesGcmAuth_avx:
push %ebp
mov %esp, %ebp
push %esi
push %edi
call .L__0002gas_3
.L__0002gas_3:
pop %esi
sub $(.L__0002gas_3-CONST_TABLE), %esi
movl (8)(%ebp), %edi
movdqa (%edi), %xmm0
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movl (20)(%ebp), %eax
movdqa (%eax), %xmm1
movl (12)(%ebp), %ecx
movl (16)(%ebp), %edx
.p2align 5, 0x90
.Lauth_loopgas_3:
movdqu (%ecx), %xmm2
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm2
add $(16), %ecx
pxor %xmm2, %xmm0
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
sub $(16), %edx
jnz .Lauth_loopgas_3
pshufb ((_u128_str-CONST_TABLE))(%esi), %xmm0
movdqa %xmm0, (%edi)
pop %edi
pop %esi
pop %ebp
ret
.p2align 5, 0x90
.globl _g9_AesGcmEnc_avx
_g9_AesGcmEnc_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
call .L__0003gas_4
.L__0003gas_4:
pop %esi
sub $(.L__0003gas_4-CONST_TABLE), %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_4
.p2align 5, 0x90
.Lblks4_loopgas_4:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher4_loopgas_4:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_4
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm1
pxor (48)(%ebx), %xmm1
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm2
pxor (64)(%ebx), %xmm2
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm3
pxor (80)(%ebx), %xmm3
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm7
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_4
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
movdqa %xmm0, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm2, (64)(%ebx)
movdqa %xmm3, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_4
.Lcombine_hashgas_4:
pshufd $(78), %xmm0, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm0, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm0, %xmm5
pclmulqdq $(0), %xmm7, %xmm0
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm0, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm0
movdqa %xmm0, %xmm4
psllq $(1), %xmm4
pxor %xmm0, %xmm4
psllq $(5), %xmm4
pxor %xmm0, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm0
pxor %xmm4, %xmm5
movdqa %xmm0, %xmm6
psrlq $(5), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm0, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm0
pxor %xmm5, %xmm0
movdqa (16)(%eax), %xmm7
pshufd $(78), %xmm1, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm1, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm1, %xmm5
pclmulqdq $(0), %xmm7, %xmm1
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm1, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm1
movdqa %xmm1, %xmm4
psllq $(1), %xmm4
pxor %xmm1, %xmm4
psllq $(5), %xmm4
pxor %xmm1, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm1
pxor %xmm4, %xmm5
movdqa %xmm1, %xmm6
psrlq $(5), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm1, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm1
pxor %xmm5, %xmm1
movdqa (%eax), %xmm7
pshufd $(78), %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm2, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm2, %xmm5
pclmulqdq $(0), %xmm7, %xmm2
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm2, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm2
movdqa %xmm2, %xmm4
psllq $(1), %xmm4
pxor %xmm2, %xmm4
psllq $(5), %xmm4
pxor %xmm2, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm2
pxor %xmm4, %xmm5
movdqa %xmm2, %xmm6
psrlq $(5), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm2, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm2
pxor %xmm5, %xmm2
pxor %xmm1, %xmm3
pxor %xmm2, %xmm3
pshufd $(78), %xmm3, %xmm6
pshufd $(78), %xmm7, %xmm4
pxor %xmm3, %xmm6
pxor %xmm7, %xmm4
pclmulqdq $(0), %xmm4, %xmm6
movdqa %xmm3, %xmm5
pclmulqdq $(0), %xmm7, %xmm3
pxor %xmm4, %xmm4
pclmulqdq $(17), %xmm7, %xmm5
pxor %xmm3, %xmm6
pxor %xmm5, %xmm6
palignr $(8), %xmm6, %xmm4
pslldq $(8), %xmm6
pxor %xmm4, %xmm5
pxor %xmm6, %xmm3
movdqa %xmm3, %xmm4
psllq $(1), %xmm4
pxor %xmm3, %xmm4
psllq $(5), %xmm4
pxor %xmm3, %xmm4
psllq $(57), %xmm4
movdqa %xmm4, %xmm6
pslldq $(8), %xmm6
psrldq $(8), %xmm4
pxor %xmm6, %xmm3
pxor %xmm4, %xmm5
movdqa %xmm3, %xmm6
psrlq $(5), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm3, %xmm6
psrlq $(1), %xmm6
pxor %xmm6, %xmm3
pxor %xmm5, %xmm3
pxor %xmm0, %xmm3
movdqa %xmm3, (32)(%ebx)
.Lsingle_block_procgas_4:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_4
.p2align 5, 0x90
.Lblk_loopgas_4:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher_loopgas_4:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_4
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm0
pxor (32)(%ebx), %xmm0
movdqa (%eax), %xmm1
pshufd $(78), %xmm0, %xmm4
pshufd $(78), %xmm1, %xmm2
pxor %xmm0, %xmm4
pxor %xmm1, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm0, %xmm3
pclmulqdq $(0), %xmm1, %xmm0
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm1, %xmm3
pxor %xmm0, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm0
movdqa %xmm0, %xmm2
psllq $(1), %xmm2
pxor %xmm0, %xmm2
psllq $(5), %xmm2
pxor %xmm0, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm0
pxor %xmm2, %xmm3
movdqa %xmm0, %xmm4
psrlq $(5), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm0, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm0
pxor %xmm3, %xmm0
movdqa %xmm0, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_4
.Lquitgas_4:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.p2align 5, 0x90
.globl _g9_AesGcmDec_avx
_g9_AesGcmDec_avx:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
sub $(152), %esp
lea (16)(%esp), %ebx
and $(-16), %ebx
movl (20)(%ebp), %eax
call .L__0004gas_5
.L__0004gas_5:
pop %esi
sub $(.L__0004gas_5-CONST_TABLE), %esi
movdqa ((_u128_str-CONST_TABLE))(%esi), %xmm4
movdqa ((_inc1-CONST_TABLE))(%esi), %xmm5
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
movdqu (%eax), %xmm0
movdqu (%ecx), %xmm1
movdqu (%edx), %xmm2
pshufb %xmm4, %xmm0
movdqa %xmm0, (%ebx)
movdqa %xmm1, (16)(%ebx)
pshufb %xmm4, %xmm2
pxor %xmm1, %xmm1
movdqa %xmm2, (32)(%ebx)
movdqa %xmm1, (48)(%ebx)
movdqa %xmm1, (64)(%ebx)
movdqa %xmm1, (80)(%ebx)
movdqa %xmm4, (96)(%ebx)
movdqa %xmm5, (112)(%ebx)
movl (28)(%ebp), %ecx
movl (12)(%ebp), %esi
movl (8)(%ebp), %edi
movl (16)(%ebp), %eax
mov $(63), %edx
and %eax, %edx
and $(-64), %eax
movl %eax, (128)(%ebx)
movl %edx, (132)(%ebx)
jz .Lsingle_block_procgas_5
.p2align 5, 0x90
.Lblks4_loopgas_5:
movdqa (112)(%ebx), %xmm5
movdqa %xmm0, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm5, %xmm2
movdqa %xmm2, %xmm3
paddd %xmm5, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm5, %xmm4
movdqa %xmm4, (%ebx)
movdqa (96)(%ebx), %xmm5
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb %xmm5, %xmm1
pshufb %xmm5, %xmm2
pshufb %xmm5, %xmm3
pshufb %xmm5, %xmm4
pxor %xmm0, %xmm1
pxor %xmm0, %xmm2
pxor %xmm0, %xmm3
pxor %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher4_loopgas_5:
aesenc %xmm0, %xmm1
aesenc %xmm0, %xmm2
aesenc %xmm0, %xmm3
aesenc %xmm0, %xmm4
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher4_loopgas_5
aesenclast %xmm0, %xmm1
aesenclast %xmm0, %xmm2
aesenclast %xmm0, %xmm3
aesenclast %xmm0, %xmm4
movdqa (16)(%ebx), %xmm0
movdqa %xmm4, (16)(%ebx)
movdqu (%esi), %xmm4
movdqu (16)(%esi), %xmm5
movdqu (32)(%esi), %xmm6
movdqu (48)(%esi), %xmm7
add $(64), %esi
pxor %xmm4, %xmm0
movdqu %xmm0, (%edi)
pshufb (96)(%ebx), %xmm4
pxor (32)(%ebx), %xmm4
pxor %xmm5, %xmm1
movdqu %xmm1, (16)(%edi)
pshufb (96)(%ebx), %xmm5
pxor (48)(%ebx), %xmm5
pxor %xmm6, %xmm2
movdqu %xmm2, (32)(%edi)
pshufb (96)(%ebx), %xmm6
pxor (64)(%ebx), %xmm6
pxor %xmm7, %xmm3
movdqu %xmm3, (48)(%edi)
pshufb (96)(%ebx), %xmm7
pxor (80)(%ebx), %xmm7
add $(64), %edi
movl (44)(%ebp), %eax
movdqa (32)(%eax), %xmm0
cmpl $(64), (128)(%ebx)
je .Lcombine_hashgas_5
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
movdqa %xmm4, (32)(%ebx)
movdqa %xmm5, (48)(%ebx)
movdqa %xmm6, (64)(%ebx)
movdqa %xmm7, (80)(%ebx)
movdqa (%ebx), %xmm0
subl $(64), (128)(%ebx)
jge .Lblks4_loopgas_5
.Lcombine_hashgas_5:
pshufd $(78), %xmm4, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm4, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm4, %xmm2
pclmulqdq $(0), %xmm0, %xmm4
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm4
movdqa %xmm4, %xmm1
psllq $(1), %xmm1
pxor %xmm4, %xmm1
psllq $(5), %xmm1
pxor %xmm4, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm3
psrlq $(5), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm4, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm4
pxor %xmm2, %xmm4
movdqa (16)(%eax), %xmm0
pshufd $(78), %xmm5, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm5, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm5, %xmm2
pclmulqdq $(0), %xmm0, %xmm5
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm1
psllq $(1), %xmm1
pxor %xmm5, %xmm1
psllq $(5), %xmm1
pxor %xmm5, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm5
pxor %xmm1, %xmm2
movdqa %xmm5, %xmm3
psrlq $(5), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm5, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm5
pxor %xmm2, %xmm5
movdqa (%eax), %xmm0
pshufd $(78), %xmm6, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm6, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm6, %xmm2
pclmulqdq $(0), %xmm0, %xmm6
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm6, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm1
psllq $(1), %xmm1
pxor %xmm6, %xmm1
psllq $(5), %xmm1
pxor %xmm6, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm6
pxor %xmm1, %xmm2
movdqa %xmm6, %xmm3
psrlq $(5), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm6, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm6
pxor %xmm2, %xmm6
pxor %xmm5, %xmm7
pxor %xmm6, %xmm7
pshufd $(78), %xmm7, %xmm3
pshufd $(78), %xmm0, %xmm1
pxor %xmm7, %xmm3
pxor %xmm0, %xmm1
pclmulqdq $(0), %xmm1, %xmm3
movdqa %xmm7, %xmm2
pclmulqdq $(0), %xmm0, %xmm7
pxor %xmm1, %xmm1
pclmulqdq $(17), %xmm0, %xmm2
pxor %xmm7, %xmm3
pxor %xmm2, %xmm3
palignr $(8), %xmm3, %xmm1
pslldq $(8), %xmm3
pxor %xmm1, %xmm2
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm1
psllq $(1), %xmm1
pxor %xmm7, %xmm1
psllq $(5), %xmm1
pxor %xmm7, %xmm1
psllq $(57), %xmm1
movdqa %xmm1, %xmm3
pslldq $(8), %xmm3
psrldq $(8), %xmm1
pxor %xmm3, %xmm7
pxor %xmm1, %xmm2
movdqa %xmm7, %xmm3
psrlq $(5), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm7, %xmm3
psrlq $(1), %xmm3
pxor %xmm3, %xmm7
pxor %xmm2, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, (32)(%ebx)
.Lsingle_block_procgas_5:
cmpl $(0), (132)(%ebx)
jz .Lquitgas_5
.p2align 5, 0x90
.Lblk_loopgas_5:
movdqa (%ebx), %xmm0
movdqa %xmm0, %xmm1
paddd (112)(%ebx), %xmm1
movdqa %xmm1, (%ebx)
movdqa (%ecx), %xmm0
lea (16)(%ecx), %eax
pshufb (96)(%ebx), %xmm1
pxor %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
movl (24)(%ebp), %edx
sub $(1), %edx
.p2align 5, 0x90
.Lcipher_loopgas_5:
aesenc %xmm0, %xmm1
movdqa (%eax), %xmm0
add $(16), %eax
dec %edx
jnz .Lcipher_loopgas_5
aesenclast %xmm0, %xmm1
movdqa (16)(%ebx), %xmm0
movdqa %xmm1, (16)(%ebx)
movdqu (%esi), %xmm1
add $(16), %esi
pxor %xmm1, %xmm0
movdqu %xmm0, (%edi)
add $(16), %edi
movl (44)(%ebp), %eax
pshufb (96)(%ebx), %xmm1
pxor (32)(%ebx), %xmm1
movdqa (%eax), %xmm0
pshufd $(78), %xmm1, %xmm4
pshufd $(78), %xmm0, %xmm2
pxor %xmm1, %xmm4
pxor %xmm0, %xmm2
pclmulqdq $(0), %xmm2, %xmm4
movdqa %xmm1, %xmm3
pclmulqdq $(0), %xmm0, %xmm1
pxor %xmm2, %xmm2
pclmulqdq $(17), %xmm0, %xmm3
pxor %xmm1, %xmm4
pxor %xmm3, %xmm4
palignr $(8), %xmm4, %xmm2
pslldq $(8), %xmm4
pxor %xmm2, %xmm3
pxor %xmm4, %xmm1
movdqa %xmm1, %xmm2
psllq $(1), %xmm2
pxor %xmm1, %xmm2
psllq $(5), %xmm2
pxor %xmm1, %xmm2
psllq $(57), %xmm2
movdqa %xmm2, %xmm4
pslldq $(8), %xmm4
psrldq $(8), %xmm2
pxor %xmm4, %xmm1
pxor %xmm2, %xmm3
movdqa %xmm1, %xmm4
psrlq $(5), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm1, %xmm4
psrlq $(1), %xmm4
pxor %xmm4, %xmm1
pxor %xmm3, %xmm1
movdqa %xmm1, (32)(%ebx)
subl $(16), (132)(%ebx)
jg .Lblk_loopgas_5
.Lquitgas_5:
movdqa (96)(%ebx), %xmm4
movdqa (%ebx), %xmm0
movdqa (16)(%ebx), %xmm1
movdqa (32)(%ebx), %xmm2
movl (36)(%ebp), %eax
movl (40)(%ebp), %ecx
movl (32)(%ebp), %edx
pshufb %xmm4, %xmm0
movdqu %xmm0, (%eax)
movdqu %xmm1, (%ecx)
pshufb %xmm4, %xmm2
movdqu %xmm2, (%edx)
add $(152), %esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
",16303,True,4931.227948985209,median
"
_init: file format elf32-i386
Disassembly of section .text:
00000000 :
char *argv[] = { ""sh"", 0 };
int
main(void)
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 53 push %ebx
e: 51 push %ecx
int pid, wpid;
if(open(""console"", O_RDWR) < 0){
f: 83 ec 08 sub $0x8,%esp
12: 6a 02 push $0x2
14: 68 78 06 00 00 push $0x678
19: e8 8e 02 00 00 call 2ac
1e: 83 c4 10 add $0x10,%esp
21: 85 c0 test %eax,%eax
23: 78 1b js 40
mknod(""console"", 1, 1);
open(""console"", O_RDWR);
}
dup(0); // stdout
25: 83 ec 0c sub $0xc,%esp
28: 6a 00 push $0x0
2a: e8 b5 02 00 00 call 2e4
dup(0); // stderr
2f: c7 04 24 00 00 00 00 movl $0x0,(%esp)
36: e8 a9 02 00 00 call 2e4
3b: 83 c4 10 add $0x10,%esp
3e: eb 58 jmp 98
mknod(""console"", 1, 1);
40: 83 ec 04 sub $0x4,%esp
43: 6a 01 push $0x1
45: 6a 01 push $0x1
47: 68 78 06 00 00 push $0x678
4c: e8 63 02 00 00 call 2b4
open(""console"", O_RDWR);
51: 83 c4 08 add $0x8,%esp
54: 6a 02 push $0x2
56: 68 78 06 00 00 push $0x678
5b: e8 4c 02 00 00 call 2ac
60: 83 c4 10 add $0x10,%esp
63: eb c0 jmp 25
for(;;){
printf(1, ""init: starting sh\\n"");
pid = fork();
if(pid < 0){
printf(1, ""init: fork failed\\n"");
65: 83 ec 08 sub $0x8,%esp
68: 68 93 06 00 00 push $0x693
6d: 6a 01 push $0x1
6f: e8 4a 03 00 00 call 3be
exit();
74: e8 f3 01 00 00 call 26c
exec(""sh"", argv);
printf(1, ""init: exec sh failed\\n"");
exit();
}
while((wpid=wait()) >= 0 && wpid != pid)
printf(1, ""zombie!\\n"");
79: 83 ec 08 sub $0x8,%esp
7c: 68 bf 06 00 00 push $0x6bf
81: 6a 01 push $0x1
83: e8 36 03 00 00 call 3be
88: 83 c4 10 add $0x10,%esp
while((wpid=wait()) >= 0 && wpid != pid)
8b: e8 e4 01 00 00 call 274
90: 85 c0 test %eax,%eax
92: 78 04 js 98
94: 39 c3 cmp %eax,%ebx
96: 75 e1 jne 79
printf(1, ""init: starting sh\\n"");
98: 83 ec 08 sub $0x8,%esp
9b: 68 80 06 00 00 push $0x680
a0: 6a 01 push $0x1
a2: e8 17 03 00 00 call 3be
pid = fork();
a7: e8 b8 01 00 00 call 264
ac: 89 c3 mov %eax,%ebx
if(pid < 0){
ae: 83 c4 10 add $0x10,%esp
b1: 85 c0 test %eax,%eax
b3: 78 b0 js 65
if(pid == 0){
b5: 85 c0 test %eax,%eax
b7: 75 d2 jne 8b
exec(""sh"", argv);
b9: 83 ec 08 sub $0x8,%esp
bc: 68 6c 09 00 00 push $0x96c
c1: 68 a6 06 00 00 push $0x6a6
c6: e8 d9 01 00 00 call 2a4
printf(1, ""init: exec sh failed\\n"");
cb: 83 c4 08 add $0x8,%esp
ce: 68 a9 06 00 00 push $0x6a9
d3: 6a 01 push $0x1
d5: e8 e4 02 00 00 call 3be
exit();
da: e8 8d 01 00 00 call 26c
000000df :
#include ""user.h""
#include ""x86.h""
char*
strcpy(char *s, const char *t)
{
df: 55 push %ebp
e0: 89 e5 mov %esp,%ebp
e2: 53 push %ebx
e3: 8b 45 08 mov 0x8(%ebp),%eax
e6: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
e9: 89 c2 mov %eax,%edx
eb: 0f b6 19 movzbl (%ecx),%ebx
ee: 88 1a mov %bl,(%edx)
f0: 8d 52 01 lea 0x1(%edx),%edx
f3: 8d 49 01 lea 0x1(%ecx),%ecx
f6: 84 db test %bl,%bl
f8: 75 f1 jne eb
;
return os;
}
fa: 5b pop %ebx
fb: 5d pop %ebp
fc: c3 ret
000000fd :
int
strcmp(const char *p, const char *q)
{
fd: 55 push %ebp
fe: 89 e5 mov %esp,%ebp
100: 8b 4d 08 mov 0x8(%ebp),%ecx
103: 8b 55 0c mov 0xc(%ebp),%edx
while(*p && *p == *q)
106: eb 06 jmp 10e
p++, q++;
108: 83 c1 01 add $0x1,%ecx
10b: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
10e: 0f b6 01 movzbl (%ecx),%eax
111: 84 c0 test %al,%al
113: 74 04 je 119
115: 3a 02 cmp (%edx),%al
117: 74 ef je 108
return (uchar)*p - (uchar)*q;
119: 0f b6 c0 movzbl %al,%eax
11c: 0f b6 12 movzbl (%edx),%edx
11f: 29 d0 sub %edx,%eax
}
121: 5d pop %ebp
122: c3 ret
00000123 :
uint
strlen(const char *s)
{
123: 55 push %ebp
124: 89 e5 mov %esp,%ebp
126: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
129: ba 00 00 00 00 mov $0x0,%edx
12e: eb 03 jmp 133
130: 83 c2 01 add $0x1,%edx
133: 89 d0 mov %edx,%eax
135: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
139: 75 f5 jne 130
;
return n;
}
13b: 5d pop %ebp
13c: c3 ret
0000013d :
void*
memset(void *dst, int c, uint n)
{
13d: 55 push %ebp
13e: 89 e5 mov %esp,%ebp
140: 57 push %edi
141: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile(""cld; rep stosb"" :
144: 89 d7 mov %edx,%edi
146: 8b 4d 10 mov 0x10(%ebp),%ecx
149: 8b 45 0c mov 0xc(%ebp),%eax
14c: fc cld
14d: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
14f: 89 d0 mov %edx,%eax
151: 5f pop %edi
152: 5d pop %ebp
153: c3 ret
00000154 :
char*
strchr(const char *s, char c)
{
154: 55 push %ebp
155: 89 e5 mov %esp,%ebp
157: 8b 45 08 mov 0x8(%ebp),%eax
15a: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for(; *s; s++)
15e: 0f b6 10 movzbl (%eax),%edx
161: 84 d2 test %dl,%dl
163: 74 09 je 16e
if(*s == c)
165: 38 ca cmp %cl,%dl
167: 74 0a je 173
for(; *s; s++)
169: 83 c0 01 add $0x1,%eax
16c: eb f0 jmp 15e
return (char*)s;
return 0;
16e: b8 00 00 00 00 mov $0x0,%eax
}
173: 5d pop %ebp
174: c3 ret
00000175 :
char*
gets(char *buf, int max)
{
175: 55 push %ebp
176: 89 e5 mov %esp,%ebp
178: 57 push %edi
179: 56 push %esi
17a: 53 push %ebx
17b: 83 ec 1c sub $0x1c,%esp
17e: 8b 7d 08 mov 0x8(%ebp),%edi
int i, cc;
char c;
for(i=0; i+1 < max; ){
181: bb 00 00 00 00 mov $0x0,%ebx
186: 8d 73 01 lea 0x1(%ebx),%esi
189: 3b 75 0c cmp 0xc(%ebp),%esi
18c: 7d 2e jge 1bc
cc = read(0, &c, 1);
18e: 83 ec 04 sub $0x4,%esp
191: 6a 01 push $0x1
193: 8d 45 e7 lea -0x19(%ebp),%eax
196: 50 push %eax
197: 6a 00 push $0x0
199: e8 e6 00 00 00 call 284
if(cc < 1)
19e: 83 c4 10 add $0x10,%esp
1a1: 85 c0 test %eax,%eax
1a3: 7e 17 jle 1bc
break;
buf[i++] = c;
1a5: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
1a9: 88 04 1f mov %al,(%edi,%ebx,1)
if(c == '\\n' || c == '\\r')
1ac: 3c 0a cmp $0xa,%al
1ae: 0f 94 c2 sete %dl
1b1: 3c 0d cmp $0xd,%al
1b3: 0f 94 c0 sete %al
buf[i++] = c;
1b6: 89 f3 mov %esi,%ebx
if(c == '\\n' || c == '\\r')
1b8: 08 c2 or %al,%dl
1ba: 74 ca je 186
break;
}
buf[i] = '\\0';
1bc: c6 04 1f 00 movb $0x0,(%edi,%ebx,1)
return buf;
}
1c0: 89 f8 mov %edi,%eax
1c2: 8d 65 f4 lea -0xc(%ebp),%esp
1c5: 5b pop %ebx
1c6: 5e pop %esi
1c7: 5f pop %edi
1c8: 5d pop %ebp
1c9: c3 ret
000001ca :
int
stat(const char *n, struct stat *st)
{
1ca: 55 push %ebp
1cb: 89 e5 mov %esp,%ebp
1cd: 56 push %esi
1ce: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
1cf: 83 ec 08 sub $0x8,%esp
1d2: 6a 00 push $0x0
1d4: ff 75 08 pushl 0x8(%ebp)
1d7: e8 d0 00 00 00 call 2ac
if(fd < 0)
1dc: 83 c4 10 add $0x10,%esp
1df: 85 c0 test %eax,%eax
1e1: 78 24 js 207
1e3: 89 c3 mov %eax,%ebx
return -1;
r = fstat(fd, st);
1e5: 83 ec 08 sub $0x8,%esp
1e8: ff 75 0c pushl 0xc(%ebp)
1eb: 50 push %eax
1ec: e8 d3 00 00 00 call 2c4
1f1: 89 c6 mov %eax,%esi
close(fd);
1f3: 89 1c 24 mov %ebx,(%esp)
1f6: e8 99 00 00 00 call 294
return r;
1fb: 83 c4 10 add $0x10,%esp
}
1fe: 89 f0 mov %esi,%eax
200: 8d 65 f8 lea -0x8(%ebp),%esp
203: 5b pop %ebx
204: 5e pop %esi
205: 5d pop %ebp
206: c3 ret
return -1;
207: be ff ff ff ff mov $0xffffffff,%esi
20c: eb f0 jmp 1fe
0000020e :
int
atoi(const char *s)
{
20e: 55 push %ebp
20f: 89 e5 mov %esp,%ebp
211: 53 push %ebx
212: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
215: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
21a: eb 10 jmp 22c
n = n*10 + *s++ - '0';
21c: 8d 1c 80 lea (%eax,%eax,4),%ebx
21f: 8d 04 1b lea (%ebx,%ebx,1),%eax
222: 83 c1 01 add $0x1,%ecx
225: 0f be d2 movsbl %dl,%edx
228: 8d 44 02 d0 lea -0x30(%edx,%eax,1),%eax
while('0' <= *s && *s <= '9')
22c: 0f b6 11 movzbl (%ecx),%edx
22f: 8d 5a d0 lea -0x30(%edx),%ebx
232: 80 fb 09 cmp $0x9,%bl
235: 76 e5 jbe 21c
return n;
}
237: 5b pop %ebx
238: 5d pop %ebp
239: c3 ret
0000023a :
void*
memmove(void *vdst, const void *vsrc, int n)
{
23a: 55 push %ebp
23b: 89 e5 mov %esp,%ebp
23d: 56 push %esi
23e: 53 push %ebx
23f: 8b 45 08 mov 0x8(%ebp),%eax
242: 8b 5d 0c mov 0xc(%ebp),%ebx
245: 8b 55 10 mov 0x10(%ebp),%edx
char *dst;
const char *src;
dst = vdst;
248: 89 c1 mov %eax,%ecx
src = vsrc;
while(n-- > 0)
24a: eb 0d jmp 259
*dst++ = *src++;
24c: 0f b6 13 movzbl (%ebx),%edx
24f: 88 11 mov %dl,(%ecx)
251: 8d 5b 01 lea 0x1(%ebx),%ebx
254: 8d 49 01 lea 0x1(%ecx),%ecx
while(n-- > 0)
257: 89 f2 mov %esi,%edx
259: 8d 72 ff lea -0x1(%edx),%esi
25c: 85 d2 test %edx,%edx
25e: 7f ec jg 24c
return vdst;
}
260: 5b pop %ebx
261: 5e pop %esi
262: 5d pop %ebp
263: c3 ret
00000264 :
name: \\
movl $SYS_ ## name, %eax; \\
int $T_SYSCALL; \\
ret
SYSCALL(fork)
264: b8 01 00 00 00 mov $0x1,%eax
269: cd 40 int $0x40
26b: c3 ret
0000026c :
SYSCALL(exit)
26c: b8 02 00 00 00 mov $0x2,%eax
271: cd 40 int $0x40
273: c3 ret
00000274 :
SYSCALL(wait)
274: b8 03 00 00 00 mov $0x3,%eax
279: cd 40 int $0x40
27b: c3 ret
0000027c :
SYSCALL(pipe)
27c: b8 04 00 00 00 mov $0x4,%eax
281: cd 40 int $0x40
283: c3 ret
00000284 :
SYSCALL(read)
284: b8 05 00 00 00 mov $0x5,%eax
289: cd 40 int $0x40
28b: c3 ret
0000028c :
SYSCALL(write)
28c: b8 10 00 00 00 mov $0x10,%eax
291: cd 40 int $0x40
293: c3 ret
00000294 :
SYSCALL(close)
294: b8 15 00 00 00 mov $0x15,%eax
299: cd 40 int $0x40
29b: c3 ret
0000029c :
SYSCALL(kill)
29c: b8 06 00 00 00 mov $0x6,%eax
2a1: cd 40 int $0x40
2a3: c3 ret
000002a4 :
SYSCALL(exec)
2a4: b8 07 00 00 00 mov $0x7,%eax
2a9: cd 40 int $0x40
2ab: c3 ret
000002ac :
SYSCALL(open)
2ac: b8 0f 00 00 00 mov $0xf,%eax
2b1: cd 40 int $0x40
2b3: c3 ret
000002b4 :
SYSCALL(mknod)
2b4: b8 11 00 00 00 mov $0x11,%eax
2b9: cd 40 int $0x40
2bb: c3 ret
000002bc