Processador do zero 1
Gente, infelizmente fiquei doente e vou ter que parar até eu melhorar
Gente, infelizmente fiquei doente e vou ter que parar até eu melhorar
A primeira versão da arquitetura está por vir, oque há de esperar??
Não sei se vocês lembram, todavia eu estava fazendo um processador do zero, se passaram muitos meses desde que abandonei este projeto, mas agora ele está mais próximo do que nunca de ser feito, eu passei estudando muito por esses meses, agora posso falar com propriedade que aprendi quase tudo de portas-logicas e etc, projetei um processador no logisim evolution, agora vou para Chips ci's discretos, dessa vez tenho sim um orçamento: 700 reais, bastante para ci's lógicos, criei uma arquitetura chamada WAR, a ALU fica no centro enquanto as outras memórias ficam em volta, com um barramento hexagonal em volta da ALU e barramentos acessórios conectando o resto para reduzir latência, agora, quero comentários e ajuda, sobre qual tipo de Ci comprar ou quais tipos de instruções usar, planejo um 8 bits na protoboard, depois um 16 bits na pcb
uma foto dele, configurações: Ryzen 5 5600gt
16gb de ram ddr4 3000mhz
SSD patriot P310 480gb
A520m a-pro
Fonte 500w onepower(ganhei uma nova de presente no caso como é surpresa n sei quantos watts que é mas tenho certeza que é 80 plus, ainda vou busca-la)
Water cooler eurus 240mm
Ventoinhas gaming master/kmex aavainfinity Nazca 35cfm, 20dba
6 ventoinhas ao todo no Pc
Gabinete usado(não sei de qual marca é)
Esse ano vou viajar para uma praia aqui no Brasil, entretanto vou levar algumas coisas de robótica como esp-32 s3, arduino e etc, para fazer algumas pesquisas cientificas por hobby, estou com medo de ter minhas coisas apreendidas, alguém que já levou isso em algum avião etc, poderia me ajudar? tipo se tenho que ter algum certificado e etc?
#aaaaaaaaaa
#ia observação: ainda sou meio iniciante
alfab = {
"a": 1,
"b": 2,
"c": 3,
'd': 4,
"e": 5,
"f": 6,
"g": 7,
"h": 8,
"i": 9,
"j": 10,
"k": 11,
"l": 12,
"m": 13,
"n": 14,
"o": 15,
"p": 16,
"q": 17,
"r": 18,
"s": 19,
"t": 20,
"u": 21,
"v": 22,
"w": 23,
"x": 24,
"y": 25,
"z": 26,
" ": 27,
"": 28,
}
alfac = {
1: "a",
2: "b",
3: "c",
4: "d",
5: "e",
6: "f",
7: "g",
8: "h",
9: "i",
10: "j",
11: "k",
12: "l",
13: "m",
14: "n",
15: "o",
16: "p",
17: "q",
18: "r",
19: "s",
20: "t",
21: "u",
22: "v",
23: "w",
24: "x",
25: "y",
26: "z",
27: " ",
28: "",
}
def comp(a,b,c,d,e,f,g,h,i,j,k,l,ta,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,zy,z0,z1):
err1 = e1 - a
err2 = e2 - b
err3 = e3 - c
err4 = e4 - d
err5 = e5 - e
err6 = e6 - f
err7 = e7 - g
err8 = e8 - h
err9 = e9 - i
err10 = e10 - j
err11= e11 - k
err12 = e12 - l
chave = (e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12)
if chave in z1:
palavra = z1[chave]
a = max(1, min(28, a))
a += ta * err1 *e1
b = max(1, min(28, b))
b += ta * err2 * e2
c = max(1, min(28, c))
c += ta * err3 * e3
d = max(1, min(28, d))
d += ta * err4 *e4
e = max(1, min(28, e))
e += ta * err5 * e5
f = max(1, min(28, f))
f += ta * err6 * e6
g = max(1, min(28, g))
g += ta * err7 *e7
h = max(1, min(28, h))
h += ta * err8 * e8
i = max(1, min(28, i))
i += ta * err9 * e9
j = max(1, min(28, j))
j += ta * err10 *e10
k = max(1, min(28, k))
k += ta * err11 * e11
l = max(1, min(28, l))
l += ta * err12 * e12
return a,b,c,d,e,f,g,h,i,j,k,l,err1,err2,err3,err4,err5,err6,err7,err8,err9,err10,err11,err12,zy,z0,z1
zy = []
mem1 = {}
mem2 = {}
while True:
try:
ah = input("Digite números ou letras com até no máximo 12 valores diferentes ou iguais: ")
filtxt = ah[:12]
filtxt = filtxt.ljust(12)
ent1,ent2,ent3,ent4,ent5,ent6,ent7,ent8,ent9,ent10,ent11,ent12 = filtxt
except ValueError:
print("Digite letras ou números válidos")
continue
try:
entt1 = alfab[ent1]
a = 1
except KeyError:
try:
entt1 = int(ent1)
a = 0
except ValueError:
continue
try:
entt2 = alfab[ent2]
b = 1
except KeyError:
try:
entt2 = int(ent2)
b = 0
except ValueError:
continue
try:
entt3 = alfab[ent3]
c = 1
except KeyError:
try:
entt3 = int(ent3)
c = 0
except ValueError:
continue
try:
entt4 = alfab[ent4]
d = 1
except KeyError:
try:
entt4 = int(ent4)
d = 0
except ValueError:
continue
try:
entt5 = alfab[ent5]
e = 1
except KeyError:
try:
entt5 = int(ent5)
e = 0
except ValueError:
continue
try:
entt6 = alfab[ent6]
f = 1
except KeyError:
try:
entt6 = int(ent6)
f = 0
except ValueError:
continue
try:
entt7 = alfab[ent7]
g = 1
except KeyError:
try:
entt7 = int(ent7)
g = 0
except ValueError:
continue
try:
entt8 = alfab[ent8]
h = 1
except KeyError:
try:
entt8 = int(ent8)
h = 0
except ValueError:
continue
try:
entt9 = alfab[ent9]
i = 1
except KeyError:
try:
entt9 = int(ent9)
i = 0
except ValueError:
continue
try:
entt10 = alfab[ent10]
j = 1
except KeyError:
try:
entt10 = int(ent10)
j = 0
except ValueError:
continue
try:
entt11 = alfab[ent11]
k = 1
except KeyError:
try:
entt11 = int(ent11)
k = 0
except ValueError:
continue
try:
entt12 = alfab[ent12]
l = 1
except KeyError:
try:
entt12 = int(ent12)
l = 0
except ValueError:
continue
chave_atual = (entt1, entt2, entt3, entt4, entt5, entt6, entt7, entt8, entt9, entt10, entt11, entt12)
if chave_atual in mem2:
print(f"resultado (Vindo da Memória): {mem2[chave_atual]}")
continue
pa = 0
pb = 0
pc = 0
pd = 0
pe = 0
pf = 0
pg = 0
ph = 0
pi = 0
pj = 0
pk = 0
pl = 0
ta = 0.0001
tenta = 0
zx = []
pa,pb,pc,pd,pe,pf,pg,ph,pi,pj,pk,pl,err1,err2,err3,err4,err5,err6,err7,err8,err9,err10,err11,err12,zy,mem1,mem2 = comp(pa,pb,pc,pd,pe,pf,pg,ph,pi,pj,pk,pl,ta,entt1,entt2,entt3,entt4,entt5,entt6,entt7,entt8,entt9,entt10,entt11,entt12,zy,mem1,mem2)
while max(abs(err1),abs(err2),abs(err3))> 1 * 10 ** -8 and tenta < 100000:
pa,pb,pc,pd,pe,pf,pg,ph,pi,pj,pk,pl,err1,err2,err3,err4,err5,err6,err7,err8,err9,err10,err11,err12,zy,mem1,mem2 = comp(pa,pb,pc,pd,pe,pf,pg,ph,pi,pj,pk,pl,ta,entt1,entt2,entt3,entt4,entt5,entt6,entt7,entt8,entt9,entt10,entt11,entt12,zy,mem1,mem2)
tenta = tenta + 1
za = round(pa)
zb = round(pb)
zc = round(pc)
zd = round(pd)
ze = round(pe)
zf = round(pf)
zg = round(pg)
zh = round(ph)
zi = round(pi)
zj = round(pj)
zk = round(pk)
zl = round(pl)
zx.append(za)
zx.append(zb)
zx.append(zc)
zx.append(zd)
zx.append(ze)
zx.append(zf)
zx.append(zg)
zx.append(zh)
zx.append(zi)
zx.append(zj)
zx.append(zk)
zx.append(zl)
ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am = zx
if za not in zy:
zy.append(za)
if zb not in zy:
zy.append(zb)
if zc not in zy:
zy.append(zc)
if zd not in zy:
zy.append(zd)
if ze not in zy:
zy.append(ze)
if zf not in zy:
zy.append(zf)
if zg not in zy:
zy.append(zg)
if zh not in zy:
zy.append(zh)
if zi not in zy:
zy.append(zi)
if zj not in zy:
zy.append(zj)
if zk not in zy:
zy.append(zk)
if zl not in zy:
zy.append(zl)
ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am = zx
if a == 1:
za = alfac.get(ab)
else:
za = ab
if b == 1:
zb = alfac.get(ac)
else:
zb = ac
if c == 1:
zc = alfac.get(ad)
else:
zc = ad
if d == 1:
zd = alfac.get(ae)
else:
zd = ae
if e == 1:
ze = alfac.get(af)
else:
ze = af
if f == 1:
zf = alfac.get(ag)
else:
zf = ag
if g == 1:
zg = alfac.get(ah)
else:
zg = ah
if h == 1:
zh = alfac.get(ai)
else:
zh = ai
if i == 1:
zi = alfac.get(aj)
else:
zi = aj
if j == 1:
zj = alfac.get(ak)
else:
zj = ak
if k == 1:
zk = alfac.get(al)
else:
zk = al
if l == 1:
zl = alfac.get(am)
else:
zl = am
print(tenta)
palavra = f"{za}{zb}{zc}{zd}{ze}{zf}{zg}{zh}{zi}{zj}{zk}{zl}".strip()
valores = tuple([ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am])
mem1[palavra] = valores
mem2[valores] = palavra
print(f"{mem1}|{mem2}")
print(f"resultado: {za}{zb}{zc}{zd}{ze}{zf}{zg}{zh}{zi}{zj}{zk}{zl}")p