Design pentru afișajul Even Realities G2: cum să construiești pentru un HUD verde de mici dimensiuni

Design pentru afișajul Even Realities G2: cum să construiești pentru un HUD verde de mici dimensiuni

Rezumat

Afișajul Even Realities G2 este conceput pentru informații scurte, care pot fi înțelese rapid. Even Hub le oferă dezvoltatorilor o suprafață de afișare de 576 x 288 pixeli per ochi, monocromă, în verde, iar SDK-ul public construiește ecranul din containere de text, listă și imagine, nu dintr-o interfață liberă, în stilul unui telefon. Prin urmare, cele mai eficiente aranjamente folosesc text scurt, spațiere clară și doar câteva elemente simultan.

Fluxul de dezvoltare se înțelege cel mai ușor ca o singură succesiune continuă: împerechezi G2 în aplicația de telefon Even Realities, te autentifici în Even Hub pe un computer cu același cont, instalezi instrumentele de dezvoltare, creezi un proiect, deschizi src/main.ts, construiești un container de text, îl previzualizezi în Simulator și apoi scanezi un cod QR în aplicația de telefon pentru a testa același aranjament pe ochelarii reali. Scopul nu este să încapă cât mai multe informații pe afișaj, ci să-i oferi purtătorului o singură informație utilă, fără să-i distragi atenția de la lumea reală.

Ce este afișajul Even Realities G2?

Even Realities G2 este o pereche de ochelari inteligenți ușori, cu afișaj binocular micro-LED cu ghid de undă. Pentru pluginurile Even Hub, ochelarii funcționează în principal ca suprafață de afișare și de introducere a comenzilor: pluginul rulează prin telefonul conectat, în timp ce G2 afișează conținutul și trimite înapoi către aplicație comenzile de pe touchpad sau de pe inelul opțional R1.

Suprafața de afișare pentru dezvoltatori are 576 x 288 pixeli per ochi și este afișată în verde, cu 16 niveluri de luminozitate. Zonele neiluminate rămân transparente, astfel încât purtătorul continuă să vadă lumea reală din spatele informațiilor. Din acest motiv, G2 se potrivește mai bine pentru indicații, traduceri, actualizări de stare și instrucțiuni scurte decât pentru pagini dense sau interfețe bogate, de tip telefon.

Vezi pagina de produs Even Realities G2

Cum să proiectezi de la zero primul tău afișaj Even G2

Pasul 1: Configurează G2 în aplicația de telefon Even Realities

Începe pe telefon. Astfel creezi contul pe care îl vei folosi și pe computer și te asiguri că ochelarii sunt pregătiți.

1. Deschide aplicația Even Realities. Creează un cont sau autentifică-te în aplicația de telefon.

2. Împerechează G2. Deschide Devices > Add device > Even G2 și urmează instrucțiunile de împerechere.

3. Actualizează firmware-ul. Acceptă orice actualizare de firmware oferită după împerechere sau verifică în Devices > Firmware.

Pasul 2: Activează accesul pentru dezvoltatori pe computer

Acum treci la computer, dar ține telefonul aproape. Folosește același cont pe ambele dispozitive.

1. Deschide Even Hub. Într-un browser de pe computer, accesează hub.evenrealities.com/login.

2. Autentifică-te cu același cont. Folosește adresa de e-mail și parola din aplicația de telefon.

3. Revino la telefon. Închide forțat aplicația Even Realities, apoi redeschide-o.

4. Găsește secțiunea pentru dezvoltatori. Deschide fila Even Hub din aplicația de telefon. Secțiunea pentru dezvoltatori ar trebui să apară acum în zona din dreapta sus, inclusiv opțiunea Scan QR.

Pasul 3: Instalează Node.js și instrumentele Even Hub

Rămâi la computer. Node.js este un software care permite rularea Even Hub pe computerul tău. Trebuie instalat înainte ca instrumentele în linie de comandă Even Hub să poată rula.

1. Instalează Node.js. În prezent, Even Hub necesită Node 20 LTS sau Node 22 ori versiuni mai noi.

2. Deschide aplicația Terminal sau PowerShell. Folosește Terminal pe macOS sau PowerShell/Terminal pe Windows.

3. Verifică Node.js. Tastează comanda de mai jos și apasă Enter. O versiune precum v20.x sau v22.x înseamnă că totul este pregătit.

node -v

4. Instalează instrumentele Even Hub. În aceeași fereastră, introdu:

npm install -g @evenrealities/evenhub-cli @evenrealities/evenhub-simulator

Pasul 4: Creează proiectul G2

Computerul este acum pregătit. Creează un nou folder de proiect și adaugă SDK-ul Even Hub în interiorul lui.

1. Creează proiectul în Terminal. Introdu aceste comenzi, câte un rând pe rând:

npm create vite@latest g2-display-demo -- --template vanilla-ts cd g2-display-demo npm install npm install @evenrealities/even_hub_sdk@latest evenhub init

Even oferă și șabloane gata făcute: npx degit even-realities/evenhub-templates/minimal g2-display-demo îți oferă un proiect în care SDK-ul și app.json sunt deja configurate

2. Finalizează app.json. Vite a creat proiectul, SDK-ul a fost instalat în interiorul acestuia, iar evenhub init a creat app.json. Deschide app.json și setează package_id (în stil domeniu inversat, de exemplu com.yourcompany.g2demo), name (maximum 20 de caractere, fără să conțină cuvântul Even) și min_sdk_version la versiunea SDK pe care ai instalat-o (o afișează npm list @evenrealities/even_hub_sdk). Adaugă o pictogramă în tonuri de gri de 24 x 24 ca public/icon.png.

Pasul 5: Deschide proiectul și găsește fișierul de afișare

Proiectul există, dar afișajul nu a fost încă proiectat. Deschide folderul într-un editor de cod.

1. Deschide Visual Studio Code sau un alt editor de cod. Visual Studio Code este o opțiune des folosită.

2. Deschide folderul proiectului. Alege File > Open Folder și selectează g2-display-demo.

3. Deschide fișierul principal. În panoul Explorer din stânga, deschide src > main.ts.

Acesta este locul-cheie: în src/main.ts se introduce primul cod de afișare G2 din pasul următor.

Pasul 6: Construiește un container de text simplu

Începe cu un singur container. Astfel confirmi că proiectul și afișajul funcționează înainte de a adăuga alte elemente de aranjare.

1. Înlocuiește codul inițial din src/main.ts. Șterge codul demonstrativ implicit Vite și lipește codul de mai jos, apoi adaugă aceste rânduri la final, astfel încât purtătorul să poată părăsi aplicația printr-o apăsare dublă. Regulile de publicare Even impun acest lucru pe primul ecran, iar evaluatorii lor îl verifică:

import { waitForEvenAppBridge, TextContainerProperty, CreateStartUpPageContainer, OsEventTypeList, } from '@evenrealities/even_hub_sdk'

const bridge = await waitForEvenAppBridge()

const statusBox = new TextContainerProperty({ xPosition: 24, yPosition: 24, width: 528, height: 240, paddingLength: 8, borderWidth: 0, containerID: 1, containerName: 'status', content: 'MACHINE 04\nReady\n> Continue', isEventCapture: 1, })

await bridge.createStartUpPageContainer( new CreateStartUpPageContainer({ containerTotalNum: 1, textObject: [statusBox], }), )

bridge.onEvenHubEvent((event) => {

if (event.textEvent?.eventType === OsEventTypeList.DOUBLE_CLICK_EVENT) {

bridge.shutDownPageContainer(1)

}

})

2. Salvează main.ts. Folosește File > Save sau Ctrl+S / Cmd+S.

  • xPosition / yPosition: Punctul în care începe containerul pe suprafața de 576 x 288.
  • width / height: Cât spațiu de afișare primește containerul.
  • paddingLength: Spațiul dintre marginea containerului și text.
  • content: Cuvintele pe care le vede purtătorul.
  • containerID / containerName: Identitatea folosită ulterior pentru a actualiza același container.
  • isEventCapture: 1: Marchează acest container drept singurul care primește principalele evenimente de atingere și glisare.

Pasul 7: Previzualizează afișajul în Even Hub Simulator

Codul este salvat. Previzualizează-l pe computer înainte de a-l trimite pe ochelarii reali.

1. Revino în Terminal. Asigură-te că te afli în continuare în folderul g2-display-demo.

2. Pornește proiectul. Introdu:

npm run dev

3. Lasă Terminalul respectiv să ruleze. De obicei, Vite afișează o adresă precum http://localhost:5173.

4. Deschide o a doua fereastră Terminal. Pornește Simulatorul cu aceeași adresă locală:

evenhub-simulator http://localhost:5173

5. Verifică Simulatorul. Ar trebui să vezi MACHINE 04, Ready și > Continue în previzualizarea de 576 x 288.

Pasul 8: Ajustează aranjamentul în același fișier src/main.ts

Nu deschide un program sau o secțiune nouă. Revino la fișierul pe care l-ai folosit deja la Pasul 6.

1. Întoarce-te în Visual Studio Code > src > main.ts. Lasă Simulatorul și serverul de dezvoltare să ruleze în continuare.

2. Modifică mai întâi conținutul. Înlocuiește cuvintele de exemplu din content cu informațiile reale pentru cazul tău de utilizare.

3. Ajustează spațierea doar dacă este necesar. Modifică xPosition, yPosition, width, height sau paddingLength, apoi salvează și uită-te din nou în Simulator.

4. Adaugă un alt container doar dacă îmbunătățește claritatea. Dacă separi un titlu, mesajul principal sau o stare, atribuie fiecărui container un containerID și un containerName unice (cel mult 16 caractere), adaugă-l în textObject și mărește containerTotalNum corespunzător. O pagină poate conține până la 8 containere de text sau listă, plus 4 containere de imagine.

Nu adăuga elemente de design de tip telefon: G2 nu oferă dimensionarea obișnuită a fontului, text îngroșat, carduri colorate sau umpleri arbitrare ale fundalului. Folosește în schimb poziția, spațierea, bordurile și nivelurile de luminozitate acceptate.

Pasul 9: Actualizează textul care se schimbă fără a reconstrui pagina

Dacă containerul rămâne în același loc și se schimbă doar cuvintele, actualizează containerul existent.

1. Rămâi în src/main.ts. În partea de sus a fișierului, acolo unde sunt importate instrumentele SDK Even Hub, adaugă TextContainerUpgrade.

2. Folosește același ID și nume de container. De exemplu:

await bridge.textContainerUpgrade( new TextContainerUpgrade({ containerID: 1, containerName: 'status', content: 'MACHINE 04\nComplete\n> Next', }), )

3. Folosește această metodă doar pentru modificări de conținut. Dacă se schimbă numărul, poziția sau dimensiunea containerelor, reconstruiește în schimb pagina. Even Realities documentează textContainerUpgrade ca opțiunea mai rapidă și fără pâlpâire pentru actualizările care privesc doar textul.

Pasul 10: Testează același aranjament pe G2 real

Simulatorul verifică structura, dar designul final ar trebui evaluat prin optica reală.

1. Fă serverul de dezvoltare accesibil de pe telefon. În mod implicit, Vite ascultă doar pe localhost, așa că telefonul nu îl poate accesa până nu îi spui să accepte conexiuni din exterior. Creează un fișier vite.config.ts în folderul proiectului (sau adaugă blocul server în cel existent) cu setările documentate de Even, apoi repornește npm run dev și lasă-l să ruleze:

import { defineConfig } from 'vite'

export default defineConfig({

server: {

host: true,

hmr: {

host: '192.168.1.100', // Înlocuiește cu adresa ta IP locală reală

},

},

})

2. Găsește adresa IP a computerului în rețeaua locală. În Windows PowerShell, folosește ipconfig și caută adresa IPv4. Pe macOS, folosește ipconfig getifaddr en0 pentru Wi-Fi.

3. Generează codul QR. Înlocuiește <YOUR-IP> cu adresa locală:

evenhub qr --url "http://<YOUR-IP>:5173"

4. Treci la telefon. Deschide aplicația Even Realities > fila Even Hub > secțiunea pentru dezvoltatori > Scan QR.

5. Scanează codul QR afișat pe computer. Telefonul încarcă proiectul local și îl transmite către G2 împerecheat.

6. Privește prin ochelari. Verifică dacă mesajul principal este ușor de găsit și de înțeles în timp ce privești mediul real.

Notă despre rețea: telefonul și computerul trebuie să se poată accesa reciproc. O rețea Wi-Fi corporativă, izolarea AP/client sau un firewall pot bloca testarea locală prin QR.

Reguli practice de aranjare pentru afișajul verde de mici dimensiuni

Un singur scop pe ecran:

  • Recomandat: Afișează o singură stare, instrucțiune, indicație sau o alegere simplă.
  • De evitat: Combinarea unui tablou de bord, a instrucțiunilor și a navigării pe aceeași pagină.

Păstrează textul scurt:

  • Recomandat: Folosește câteva rânduri compacte.
  • De evitat: Tratarea limitei tehnice de text ca țintă de design.

Folosește spațierea pentru ierarhie:

  • Recomandat: Separă titlul, informația principală și acțiunea prin spațiu liber.
  • De evitat: Încercarea de a crea ierarhie prin modificări ale dimensiunii fontului, care nu sunt acceptate.

Folosește containerele în mod deliberat:

  • Recomandat: Adaugă un container doar atunci când îi conferă informației un rol clar.
  • De evitat: Adăugarea de containere doar pentru că pagina permite până la 12.

Proiectează ținând cont de transparență:

  • Recomandat: Nu uita că zonele neiluminate lasă să se vadă lumea reală din spatele HUD-ului.
  • De evitat: Tratarea suprafeței de afișare ca pe ecranul opac al unui telefon.

Folosește imaginile cu grijă:

  • Recomandat: Folosește pictograme simple, cu contrast ridicat, sau indicii compacte.
  • De evitat: Fotografii sau grafice detaliate care trebuie examinate îndeaproape.

Testează pe hardware:

  • Recomandat: Folosește Simulatorul pentru viteză, apoi verifică pe G2 real.
  • De evitat: Aprobarea designului final doar pe baza previzualizării de pe desktop.

Ce informații de business se potrivesc acestui afișaj?

G2 dă cele mai bune rezultate atunci când purtătorul are nevoie de o cantitate mică de informații fără să abandoneze sarcina sau conversația în curs.

· Indicații pentru ședințe: numele unui vorbitor, o cifră-cheie, un punct de discuție sau un memento scurt.

· Traducere în timp real: unul sau două rânduri de vorbire tradusă, în loc de o pagină întreagă de transcriere.

· Fluxuri de lucru ghidate: câte o instrucțiune sau un pas de confirmare pe rând.

· Actualizări de stare: starea unui utilaj, stadiul unei livrări, progresul unei sarcini sau o alertă scurtă.

· Indicii de navigare: o direcție, o distanță sau o săgeată simplă, în locul unei hărți detaliate.

· Indicații de cunoștințe: un răspuns scurt, un număr de referință sau o notă contextuală.

De ce contează pentru companii un design bun al afișajului G2

Valoarea G2 nu stă în câtă informație încape pe afișaj, ci în cât de puțină atenție are nevoie afișajul. Un HUD scurt și bine structurat poate aduce în prim-plan informații utile fără ca angajații să fie nevoiți să se oprească din ce fac și să deschidă un telefon sau un laptop. Pentru companii, acest lucru poate contribui la ședințe mai concentrate, acces mai rapid la informațiile de stare și fluxuri de lucru pas cu pas mai consecvente.

Limitările de design pot ajuta, de asemenea, echipele să mențină disciplina în aplicațiile personalizate. Reutilizarea unui număr mic de containere, conținutul scurt și interacțiunile previzibile fac interfețele mai ușor de învățat și reduc riscul ca ochelarii să devină încă o aplicație aglomerată.

Concluzie

Proiectarea pentru afișajul Even Realities G2 începe pe telefon, prin împerecherea și actualizarea ochelarilor, apoi continuă pe computer: activezi accesul la Even Hub, instalezi Node.js și instrumentele Even Hub, creezi un proiect Vite și deschizi src/main.ts, unde primul HUD verde de 576 x 288 este construit dintr-un simplu container de text. Previzualizează aranjamentul în Even Hub Simulator, ajustează conținutul și spațierea în același fișier, folosește textContainerUpgrade atunci când se schimbă doar cuvintele și, în final, scanează codul QR de dezvoltare în aplicația Even Realities pentru a testa aranjamentul pe G2 real. Cele mai reușite interfețe de business păstrează fiecare ecran scurt, concentrat și ușor de înțeles dintr-o privire, permițând companiilor să afișeze traduceri, indicații, informații de stare sau instrucțiuni de lucru fără a le distrage mereu angajaților atenția de la sarcina fizică sau de la conversație pentru a verifica un alt ecran.

Construiești un flux de lucru personalizat pentru Even G2? Începe cu un singur ecran util, testează-l în Simulator și pe ochelarii reali, apoi extinde-l doar atunci când următoarea informație îmbunătățește clar sarcina purtătorului.

Întrebări frecvente

Acest articol

Folosește suprafața de afișare pentru dezvoltatori de 576 x 288 per ochi, documentată de Even Hub. Even Realities indică și o rezoluție optică hardware de 640 x 350, dar coordonatele de aranjare ale pluginurilor sunt raportate la suprafața Even Hub de 576 x 288.

Nu. Even Hub pune la dispoziție un afișaj monocrom verde, cu 16 niveluri de luminozitate.

Nu printr-o suprafață grafică obișnuită, cu formă liberă. Paginile Even Hub sunt construite din containere de text, listă și imagine plasate la coordonate specifice.

Sistemul public de afișare folosește fontul integrat în firmware și nu oferă comenzile obișnuite pentru dimensiunea fontului, text îngroșat sau cursiv, așa că ierarhia trebuie creată prin poziție, spațiere, borduri și luminozitate.

Deschide proiectul într-un editor de cod și accesează src > main.ts.

Rulează npm run dev, apoi deschide un al doilea Terminal și pornește evenhub-simulator cu adresa locală Vite.

Lasă serverul de dezvoltare să ruleze, generează un cod QR cu evenhub qr, apoi deschide aplicația Even Realities > fila Even Hub > secțiunea pentru dezvoltatori > Scan QR.