इमुलेटिंग लिनस टोरवाल्ड्स: स्क्रॅचपासून आपली स्वतःची ऑपरेटिंग सिस्टम तयार करा (II)

या प्रकरणात नेक्स्टडिव्हलमध्ये आपली स्वतःची ऑपरेटिंग सिस्टम कशी तयार करावी यावरील दुसर्‍या पोस्टवर आपले स्वागत आहे.

जर आपण कोडच्या कोडकडे परत जाऊ प्रथम पोस्ट प्रत्येक गोष्टीच्या शेवटी असे काहीतरी घेऊन यायला हवे होतेः

नेक्स्टडिव्हल -1

हे बरोबर असल्यास आम्ही सुरू ठेवू शकतो. मी माझ्याकडे गीटहब वर असलेली सिस्टीम आणि संरचना वापरणार आहे (http://github.com/AdrianArroyoCalle/next-divel) कारण ते माझ्यासाठी आणि आपल्यासाठी अधिक सोयीस्कर आहे. मजकूर हा एक मूलभूत मजकूर आहे हे आपण पाहू शकता, ते आकर्षक नाही. हे कदाचित सामान्यपेक्षा काहीतरी असू शकते. परंतु ही म्हण आहे की रंगांचा स्वाद घेणे आणि आमच्या ऑपरेटिंग सिस्टममध्ये रंग असतील. आम्ही घालण्यास सक्षम होणार असलेले पहिले रंग व्हीजीए कार्ड परिभाषित करणारे आहेत आणि ते 0 आहेत:

  1. काळा
  2. निळा
  3. हिरव्या
  4. निळसर
  5. Rojo
  6. किरमिजी
  7. तपकिरी
  8. फिकट राखाडी
  9. गडद राखाडी
  10. फिकट निळा
  11. हलका हिरवा
  12. निळसर स्पष्ट
  13. फिकट लाल
  14. फिकट किरमिजी
  15. फिकट तपकिरी
  16. पांढरा

हे रंग अधिक सुलभ होण्यासाठी आम्ही हेडरमध्ये हे परिभाषित करणार आहोत आणि कदाचित भविष्यात सिस्टम एपीआयचा एक भाग बनू. म्हणून आम्ही नेक्स्टडिव्हल समावेशामध्ये एनडी_बोर्ड. एचपी फाईल तयार करतो.

#ifndef ND_COLOR_HPP
#define ND_COLOR_HPP
typedef enum ND_Color{
ND_COLOR_BLACK = 0,
ND_COLOR_BLUE = 1,
ND_COLOR_GREEN = 2,
ND_COLOR_CYAN = 3,
ND_COLOR_RED = 4,
ND_COLOR_MAGENTA = 5,
ND_COLOR_BROWN = 6,
ND_COLOR_LIGHT_GREY = 7,
ND_COLOR_DARK_GREY = 8,
ND_COLOR_LIGHT_BLUE = 9,
ND_COLOR_LIGHT_GREEN = 10,
ND_COLOR_LIGHT_CYAN = 11,
ND_COLOR_LIGHT_RED = 12,
ND_COLOR_LIGHT_MAGENTA = 13,
ND_COLOR_LIGHT_BROWN = 14,
ND_COLOR_WHITE = 15
} ND_Color;
#endif

त्याच वेळी आम्ही स्क्रीनवर अधिक सोयीस्कर पद्धतीने लिहिण्यासाठी नवीन कार्ये परिभाषित करणार आहोत (नाही, आम्ही अद्याप प्रिंटफची अंमलबजावणी करणार नाही, मला माहित आहे की आपल्याला ते हवे आहे). आम्ही स्क्रीनशी संबंधित कार्ये (ND_Screen.cpp आणि ND_Screen.hpp) च्या संचासाठी एक फाईल आणि त्याचे शीर्षलेख तयार करु. त्यामध्ये आपण कार्ये तयार करू: अक्षरे आणि पार्श्वभूमीचा रंग बदलणे, वाक्य आणि अक्षरे लिहा, स्क्रीन स्वच्छ करा आणि स्क्रीनच्या आसपास हलवा. आम्ही व्हीजीए स्क्रीन वापरणे सुरू ठेवत आहोत परंतु आता आम्ही काही बाइट वापरणार आहोत ज्यामुळे रंग मिळेल. ND_Screen.cpp असे दिसेल:

/**
* @file ND_Screen.cpp
* @author Adrián Arroyo Calle
* @brief Implements four easy functions for write strings directly
*/
#include <ND_Types.hpp>
#include <ND_Color.hpp>
#include <ND_Screen.hpp>
uint16_t *vidmem= (uint16_t *)0xB8000;
ND_Color backColour = ND_COLOR_BLACK;
ND_Color foreColour = ND_COLOR_WHITE;
uint8_t cursor_x = 0;
uint8_t cursor_y = 0;
/**
* @brief Gets the current color
* @param side The side to get the color
* */
ND_Color ND::Screen::GetColor(ND_SIDE side)
{
if(side==ND_SIDE_BACKGROUND){
return backColour;
}else{
return foreColour;
}
}
/**
* @brief Sets the color to a screen side
* @param side The side to set colour
* @param colour The new colour
* @see GetColor
* */
void ND::Screen::SetColor(ND_SIDE side, ND_Color colour)
{
if(side==ND_SIDE_BACKGROUND)
{
backColour=colour;
}else{
foreColour=colour;
}
}
/**
* @brief Puts the char on screen
* @param c The character to write
* */
void ND::Screen::PutChar(char c)
{
uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
uint16_t attribute = attributeByte << 8; uint16_t *location; if (c == 0x08 && cursor_x) { cursor_x--; }else if(c == '\r') { cursor_x=0; }else if(c == '\n') { cursor_x=0; cursor_y=1; } if(c >= ' ') /* Printable character */
{
location = vidmem + (cursor_y*80 + cursor_x);
*location = c | attribute;
cursor_x++;
}
if(cursor_x >= 80) /* New line, please*/
{
cursor_x = 0;
cursor_y++;
}
/* Scroll if needed*/
uint8_t attributeByte2 = (0 /*black*/ << 4) | (15 /*white*/ & 0x0F);
uint16_t blank = 0x20 /* space */ | (attributeByte2 << 8); if(cursor_y >= 25)
{
int i;
for (i = 0*80; i < 24*80; i++)
{
vidmem[i] = vidmem[i+80];
}
// The last line should now be blank. Do this by writing
// 80 spaces to it.
for (i = 24*80; i < 25*80; i++)
{
vidmem[i] = blank;
}
// The cursor should now be on the last line.
cursor_y = 24;
}
}
/**
* @brief Puts a complete string to screen
* @param str The string to write
* */
void ND::Screen::PutString(const char* str)
{
int i=0;
while(str[i])
{
ND::Screen::PutChar(str[i++]);
}
}
/**
* @brief Cleans the screen with a color
* @param colour The colour to fill the screen
* */
void ND::Screen::Clear(ND_Color colour)
{
uint8_t attributeByte = (colour /*background*/ << 4) | (15 /*white - foreground*/ & 0x0F);
uint16_t blank = 0x20 /* space */ | (attributeByte << 8);
int i;
for (i = 0; i < 80*25; i++)
{
vidmem[i] = blank;
}
cursor_x = 0;
cursor_y = 0;
}
/**
* @brief Sets the cursor via software
* @param x The position of X
* @param y The position of y
* */
void ND::Screen::SetCursor(uint8_t x, uint8_t y)
{
cursor_x=x;
cursor_y=y;
}

हेडर हे मूलभूत असेल म्हणून मी येथे ते समाविष्ट करीत नाही, परंतु एनडी_एसआयडीई प्रकारची व्याख्या हायलाइट करते

typedef enum ND_SIDE{
ND_SIDE_BACKGROUND,
ND_SIDE_FOREGROUND
} ND_SIDE;

हे देखील नमूद करा की आम्ही एनडी_टाइप. एचडीपी हेडर वापरत आहोत, हेडर चार्ट आणि इन्टवर आधारित uint8_t, uint16_t इत्यादींसाठी काही मूलभूत प्रकार परिभाषित करतो. वास्तविक हे हेडर सी 99 मानकांपैकी एक आहे आणि खरं तर माझे एनडीटिप्प्स एचपीपी हे लिनक्समधील फाईलची एक कॉपी / पेस्ट आहे, जेणेकरून आपण त्यांची देवाणघेवाण करू शकता आणि काहीही होणार नाही (फक्त परिभाषा आहेत, कार्य नाहीत).

हा कोड कार्य करतो की नाही हे तपासण्यासाठी आपण कर्नलचा C प्रविष्टी बिंदू सुधारित करणार आहोत.

ND::Screen::Clear(ND_COLOR_WHITE);
ND::Screen::SetColor(ND_SIDE_BACKGROUND,ND_COLOR_WHITE);
ND::Screen::SetColor(ND_SIDE_FOREGROUND,ND_COLOR_GREEN);
ND::Screen::PutString("NextDivel\n");
ND::Screen::SetColor(ND_SIDE_FOREGROUND,ND_COLOR_BLACK);
ND::Screen::PutString("Licensed under GNU GPL v2");

आणि आम्ही या चरणांचे अनुसरण केल्यास आम्हाला हा परिणाम मिळेल

नेक्स्टडिव्हल -3

आम्ही तयार केलेल्या या कार्यांबद्दल धन्यवाद आम्ही लहान जीयूआय बनविणे सुरू करू शकतो, जसे की कर्नल पॅनीक जे आम्ही प्रत्येक वेळी दर्शवू शकणार नाही तेव्हा एक पुनर्प्राप्त न होणारी त्रुटी आली. यासारखेच काहीसे:

नेक्स्टडिव्हल -4

आणि ही छोटी जीयूआय आम्ही केवळ या कार्येद्वारे बनविली:

void ND::Panic::Show(const char* error)
{
ND::Screen::Clear(ND_COLOR_RED);
ND::Screen::SetColor(ND_SIDE_BACKGROUND, ND_COLOR_WHITE);
ND::Screen::SetColor(ND_SIDE_FOREGROUND, ND_COLOR_RED);
ND::Screen::SetCursor(29,10); //(80-22)/2
ND::Screen::PutString("NextDivel Kernel Error\n");
ND::Screen::SetCursor(15,12);
ND::Screen::PutString(error);
}

आणि येथे पोस्ट. मी तुम्हाला सिस्टम 0 पासून संकलित करण्याच्या सूचनांची आठवण करून देतो:

git clone http://github.com/AdrianArroyoCalle/next-divel
cd next-divel
mkdir build && cd build
cmake ..
make
make DESTDIR=next install
chmod +x iso.sh
./iso.sh
qemu-system-i386 nextdivel.iso

आणि मी पहिल्या पोस्टच्या उत्कृष्ट स्वागतार्थ धन्यवाद दिल्याबद्दल मी ही संधी घेतो.


लेखाची सामग्री आमच्या तत्त्वांचे पालन करते संपादकीय नीति. त्रुटी नोंदविण्यासाठी क्लिक करा येथे.

5 टिप्पण्या, आपल्या सोडा

आपली टिप्पणी द्या

आपला ई-मेल पत्ता प्रकाशित केला जाणार नाही.

*

*

  1. डेटा जबाबदार: मिगुएल Áन्गल गॅटन
  2. डेटाचा उद्देशः नियंत्रण स्पॅम, टिप्पणी व्यवस्थापन.
  3. कायदे: आपली संमती
  4. डेटा संप्रेषण: कायदेशीर बंधन वगळता डेटा तृतीय पक्षास कळविला जाणार नाही.
  5. डेटा संग्रहण: ओकेन्टस नेटवर्क (EU) द्वारा होस्ट केलेला डेटाबेस
  6. अधिकारः कोणत्याही वेळी आपण आपली माहिती मर्यादित, पुनर्प्राप्त आणि हटवू शकता.

  1.   F3niX म्हणाले

    उत्कृष्ट मित्रा, तरीही मी सी ++ मधील कोड समजून घेण्यासाठी माझे हेल्मेट मारत आहे.

    ग्रीटिंग्ज

  2.   पंडाक्रिस म्हणाले

    या वस्तू छान आहेत. प्रोसेसरच्या निम्न-स्तरीय कामगिरीबद्दल त्यांनी माझी उत्सुकता पुन्हा एकदा स्पष्ट केली आहे.
    कदाचित माझ्याकडे वेळ असेल तर मी पुढच्या डायव्हलसह खेळण्यास सुरूवात करीन.
    मी बराच काळ लेख पाठविला नाही. आधीच आवश्यक

  3.   जॉन बुरोस म्हणाले

    ठीक आहे, हा मार्ग आहे.

  4.   Miguel म्हणाले

    ऑपरेटिंग सिस्टम कसे बनवायचे हे जाणून घेण्यासाठी मला फार पूर्वीपासून इच्छा आहे.

    आपल्या पुढच्या पोस्टची वाट पहात आहे. चीअर्स

  5.   जिउलिआनो म्हणाले

    मस्त मित्र!
    मला फक्त एक समस्या आहे, या उदाहरणाची सी मध्ये एखादी व्यक्ती मला फाइल देऊ शकेल?
    हे टर्मिनलमध्ये नेहमी मला चुका पाठवते