Arduino/C3/Digital-Logic-Design-with-Arduino/Kannada

From Script | Spoken-Tutorial
Revision as of 13:16, 10 May 2020 by Melkamiyar (Talk | contribs)

Jump to: navigation, search
Time Narration
00:01 ಆರ್ಡುಯಿನೊ ಜೊತೆಗಿನ ಡಿಜಿಟಲ್ ಲಾಜಿಕ್ ಡಿಸೈನ್ ಕುರಿತ ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಗೆ ಸ್ವಾಗತ.
00:07 ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು: assembly ಯಲ್ಲಿ AND, OR ಮತ್ತು XOR ಅಪರೇಶನ್ ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಪರಿಶೀಲಿಸಲು,
00:17 ಸರಳ ಕಾಂಬಿನೇಶನಲ್ ಲಾಜಿಕ್ ಕಾರ್ಯಗತಗೊಳಿಸಿ ಪರಿಶೀಲಿಸಲು ಕಲಿಯಲಿದ್ದೇವೆ.
00:21 ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನುಸರಿಸಲು ನೀವು ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್ ಮತ್ತು Assembly ಲ್ಯಾಂಗ್ವೇಜ್ ನ ಮೂಲಜ್ಞಾನ ಹೊಂದಿರಬೇಕು.
00:31 ಈ ಟ್ಯುಟೋರಿಯಲ್ ರೆಕಾರ್ಡ್ ಮಾಡಲು ನಾನು: ಆರ್ಡುಯಿನೊ ಯು.ಎನ್.ಒ ಬೋರ್ಡ್ ಮತ್ತು
00:38 ಉಬಂಟು ಲೀನಕ್ಸ್ ಅಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂ ವರ್ಶನ್ 14.04 ಬಳಸುತ್ತಿದ್ದೇನೆ.
00:44 ನಮಗೆ ಈ ಬಾಹ್ಯ ಸಾಧನಗಳು ಬೇಕು:

ಅವೆಂದರೆ ಬ್ರೆಡ್ ಬೋರ್ಡ್,

00:51 ಆರ್ಡುಯಿನೊ ಯು.ಎನ್.ಒ ಬೋರ್ಡ್,
00:54 ಸೆವೆನ್ ಸೆಗ್ಮೆಂಟ್ ಡಿಸ್ಪ್ಲೇ,
00:57 220-ohm ರೆಸಿಸ್ಟರ್,
01:00 ಡಿಕೋಡರ್ (7447 IC) ಮತ್ತು

ಜಂಪರ್ ವೈರ್ ಗಳು.

01:07 ಹಿಂದಿನ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು ಡಿಕೋಡರ್ ಗೆ ಬಳಸಿದ ಸರ್ಕಿಟ್ ಸೆಟಪ್ ಅನ್ನೇ ಈಗ ಬಳಸಲಿದ್ದೇವೆ.
01:14 ನಾವು ಲೈವ್ ಕನೆಕ್ಷನ್ ಸೆಟಪ್ ನೋಡೋಣ.
01:17 ಲಾಜಿಕಲ್ AND ಅಪರೇಶನ್ ಗಳನ್ನು ದೃಢೀಕರಿಸಲು ನಾವೀಗ assembly ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲಿದ್ದೇವೆ.
01:24 ಯಾವುದೇ ಟೆಕ್ಸ್ಟ್ ಎಡಿಟರ್ ತೆರೆಯಿರಿ ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ ಟೈಪ್ ಮಾಡಿ.
01:29 ಈ ಟ್ಯುಟೋರಿಯಲ್ ನ code files ಲಿಂಕ್ ನಲ್ಲಿ m328Pdef.inc ಮತ್ತು ಸೋರ್ಸ್ ಕೋಡ್ ಲಭ್ಯ.
01:38 ನೀವಿದನ್ನು ಡೌನ್ ಲೋಡ್ ಮಾಡಿ ಬಳಸಬಹುದು.
01:41 ಹೈಲೈಟ್ ಮಾಡಿದ ಕೋಡ್, ಆರ್ಡುಯಿನೊವಿನ 2, 3, 4 ಮತ್ತು 5 ಪಿನ್ ಗಳನ್ನು ಔಟ್ಪುಟ್ ಪಿನ್ ಗಳಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ.
01:49 ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಬೂಲಿಯನ್ ಅಪರೇಶನ್ ಗಳಿಗೆ r16 ಮತ್ತು r17 ನ ಮೊದಲ ಬಿಟ್ ಮಾತ್ರ ಪರಿಗಣಿಸುತ್ತಿದ್ದೇವೆ. ಇಲ್ಲಿ ಇವೆರಡೂ 1 ಆಗಿವೆ.
02:00 ಈ ಸಾಲು, r16 ಮತ್ತು r17 ರ ಬಿಟ್ ಗಳಲ್ಲಿ ಬಿಟ್ ವೈಸ್ AND ಅಪರೇಶನ್ ನಡೆಸುತ್ತದೆ. ಫಲಿತಾಂಶವನ್ನು r16 ರಲ್ಲಿ ಶೇಖರಿಸಲಾಗುತ್ತದೆ.
02:12 ಉಳಿದ ಪ್ರೋಗ್ರಾಂ, ಈ ಔಟ್ಪುಟ್ ಅನ್ನು ಡಿಸ್ಪ್ಲೇ ಮಾಡುವುದನ್ನು ನೋಡಿಕೊಳ್ಳುತ್ತದೆ.
02:17 r16LSB ಯು ನಮ್ಮ ಫಲಿತಾಂಶವನ್ನು ಹೊಂದಿದೆ. ಇದನ್ನು ಎಡಕ್ಕೆ ಎರಡು ಸ್ಥಾನಗಳಷ್ಟು ಸ್ಥಳಾಂತರಿಸಬೇಕು.
02:26 ಕೋಡ್ ನ ಈ ಸಾಲು, ಲೂಪ್ ಅನ್ನು loopw ಎಂದು ಕರೆಯುತ್ತದೆ.
02:31 ಈ ಲೂಪ್, r16LSB ಯನ್ನು ಸ್ಥಳಾಂತರಿಸುವುದನ್ನು ನೋಡಿಕೊಳ್ಳುತ್ತದೆ.
02:38 r16 ರಲ್ಲಿ ಮೌಲ್ಯವನ್ನು PORTD ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಇದು, ಸೆವೆನ್ ಸೆಗ್ಮೆಂಟ್ ಡಿಸ್ಪ್ಲೇಯಲ್ಲಿ 0 ಅಥವಾ 1 ಅನ್ನು ಡಿಸ್ಪ್ಲೇ ಮಾಡುತ್ತದೆ.
02:48 ಇಲ್ಲಿ r16 ರ ಅಂಶಗಳನ್ನು ಒಮ್ಮೆ ಎಡಕ್ಕೆ ಸ್ಥಳಾಂತರಿಸಲಾಗುತ್ತದೆ. ನಂತರ r20 ರ ಮೌಲ್ಯವನ್ನು 1 ರಷ್ಟು ಇಳಿಸಲಾಗುತ್ತದೆ.
02:58 r20 ರಮೌಲ್ಯ ಶೂನ್ಯಕ್ಕೆ ಸಮನಾಗಿರದೆ ಇದ್ದಲ್ಲಿ ಲೂಪ್ ಅನ್ನು ಇನ್ನೊಮ್ಮೆ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ.
03:05 ನಾನು ಕೋಡ್ ಅನ್ನು home slash spoken slash Assembly ಫೋಲ್ಡರ್ ನಲ್ಲಿ boolean.asm ಆಗಿ ಸೇವ್ ಮಾಡುತ್ತೇನೆ.
03:15 terminal ಗೆ ಮರಳಿ.
03:18 boolean.asm ಸೇವ್ ಮಾಡಿರುವ ಫೋಲ್ಡರ್ ಗೆ ಹೋಗಿ. avra space boolean.asm ಎಂದು ಟೈಪ್ ಮಾಡಿ Enter ಒತ್ತಿ.
03:29 ಇದು ಕೋಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು boolean.hex ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
03:34 ಸ್ಕ್ರೀನ್ ಅನ್ನು ತೆರವುಗೊಳಿಸೋಣ.
03:36 ನಂತರ ನಾವು ಕೋಡ್ ಅನ್ನು ಆರ್ಡುಯಿನೊ ಗೆ ಅಪ್ ಲೋಡ್ ಮಾಡಬೇಕು.
03:41 ಇದಕ್ಕಾಗಿ avrdude space hyphen p space atmega328p space hyphen c space arduino space hyphen b space 115200 space hyphen capital P space forward slash dev forward slash ttyACM0 space hyphen capital U space flash colon w colon boolean dot hex ಎಂದು ಟೈಪ್ ಮಾಡಿ ಮತ್ತು Enter ಒತ್ತಿ.
04:17 ಈಗ, ಸೆವೆನ್ ಸೆಗ್ಮೆಂಟ್ ಡಿಸ್ಪ್ಲೇಯಲ್ಲಿ ಒಂದು ಅಂಕಿಯು ಮಿನುಗುತ್ತಿರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು.
04:23 ಕೆಳಗಿನ ಅಸೈನ್ ಮೆಂಟ್ ಮಾಡಲು ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಪಾಸ್ (Pause) ಮಾಡಿ.
04:27 AND ನ ಉಳಿತ ಟ್ರುತ್ ಟೇಬಲ್ ದೃಢೀಕರಿಸಲು r16 ಮತ್ತು r17 ಮೌಲ್ಯಗಳನ್ನು ಮಾರ್ಪಡಿಸಿ.
04:35 ಲಾಜಿಕಲ್ OR ಅಪರೇಶನ್ ನೆರವೇರಿಸಲು, ಪ್ರೋಗ್ರಾಂ ನ and ಕೀವರ್ಡ್ ಅನ್ನು or ಜೊತೆ ಬದಲಾಯಿಸಿ.
04:42 ಲಾಜಿಕಲ್ XOR ಅಪರೇಶನ್ ನೆರವೇರಿಸಲು, ಪ್ರೋಗ್ರಾಂ ನ and ಕೀವರ್ಡ್ ಅನ್ನು xor ಜೊತೆ ಬದಲಾಯಿಸಿ.
04:49 ನಂತರ ನಾವು ಕೆಲವು ಸರಳ ಕಾಂಬಿನೇಶನಲ್ ಲಾಜಿಕ್ ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಪರಿಶೀಲಿಸಲಿದ್ದೇವೆ.
04:55 ನಾವೀಗ ಲೈವ್ ಕನೆಕ್ಷನ್ ಸೆಟಪ್ ನೋಡೋಣ. ಇದು ಹಿಂದಿನ ಸೆಟಪ್ ನಂತೆಯೇ ಆಗಿರುತ್ತದೆ.
05:02 ನಾವು ಈ ಸಮೀಕರಣಗಳನ್ನು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಿದ್ದೇವೆ ಮತ್ತು ಅವುಗಳ ಟ್ರುತ್ ಟೇಬಲ್ ದೃಢೀಕರಿಸಲಿದ್ದೇವೆ.
05:09 ಮೇಲೆ ತೋರಿಸಿರುವ ಸಮೀಕರಣಗಳಿಗೆ ಇದು ಟ್ರುತ್ ಟೇಬಲ್ ಆಗಿದೆ.
05:14 ಇಲ್ಲಿ W, X, Y ಮತ್ತು Z ಗಳು ಇನ್ಪುಟ್ ಗಳಾಗಿವೆ.
05:19 A, B, C ಮತ್ತು D ಗಳು ಔಟ್ಪುಟ್ ಗಳು. ನಾವು ಟ್ರುತ್ ಟೇಬಲ್ ನ ಮೊದಲ ಸಾಲನ್ನು ಪರಿಗಣಿಸೋಣ. ಹೀಗೆ, ಎಲ್ಲಾ ಇನ್ಪುಟ್ ಗಳು ಶೂನ್ಯ ಆಗಿರುತ್ತವೆ.
05:31 ಟ್ರುತ್ ಟೇಬಲ್ ಪ್ರಕಾರ, ನಾವು 1 ಔಟ್ಪುಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು.
05:36 ನಾವು ಸೆವೆನ್ ಸೆಗ್ಮೆಂಟ್ ಡಿಸ್ಪ್ಲೇಯಲ್ಲಿ ಔಟ್ಪುಟ್ ಅನ್ನು ಡಿಸ್ಪ್ಲೇ ಮಾಡುತ್ತೇವೆ.
05:40 ಈ ಸಮೀಕರಣಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ದೃಢೀಕರಿಸಲು ನಾವು assembly ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯೋಣ.
05:46 ಯಾವುದೇ ಟೆಕ್ಸ್ಟ್ ಎಡಿಟರ್ ತೆರೆಯಿರಿ ಮತ್ತು ಈ ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ.
05:50 ನಾನು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಟೈಪ್ ಮಾಡುತ್ತೇನೆ.
05:53 ಈ ಸಾಲು, ಆರ್ಡುಯಿನೊವಿನ 2, 3, 4 ಮತ್ತು 5 ಪಿನ್ ಗಳನ್ನು ಔಟ್ಪುಟ್ ಪಿನ್ ಗಳಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ.
06:00 r30, ಔಟ್ಪುಟ್ ಅನ್ನು ಶೇಖರಿಸಲು ಡಮ್ಮಿ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ.
06:05 W, X, Y ಮತ್ತು Z ಇನ್ಪುಟ್ ವೇರಿಯೇಬಲ್ ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಕ್ರಮವಾಗಿ r17, r18, r19 ಮತ್ತು r20 ರಿಜಿಸ್ಟರ್ ಗಳಲ್ಲಿ ಶೇಖರಿಸಲಾಗುತ್ತದೆ.
06:16 r17, r18, r19 ಮತ್ತು r20 ಮೌಲ್ಯಗಳನ್ನು r0, r1, r2 ಮತ್ತು r3 ಡಮ್ಮಿ ವೇರಿಯೇಬಲ್ ಗಳಲ್ಲಿ ಶೇಖರಿಸಲಾಗುತ್ತದೆ.
06:27 ಈ ಮೌಲ್ಯಗಳನ್ನು, ಅಪರೇಶನ್ ಗಳನ್ನು ನಿರ್ವಹಿಸಿದ ನಂತರ ಮೂಲ ರಿಜಿಸ್ಟರ್ ಗಳನ್ನು ಪೂರ್ವಸ್ಥಿತಿಗೆ ತರಲು ಬಳಸಲಾಗುತ್ತದೆ.
06:35 ವೇರಿಯೇಬಲ್ ನ ಕಾಂಪ್ಲಿಮೆಂಟ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು 'comp' ಸಬ್ ರೂಟಿನ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
06:41 W, X, Y ಮತ್ತು Z ನ ಕಾಂಪ್ಲಿಮೆಂಟ್ ಅನ್ನು ಕ್ರಮವಾಗಿ r21, r22, r23 ಮತ್ತು r24 ರಲ್ಲಿ ಲೆಕ್ಕ ಹಾಕಲಾಗುತ್ತದೆ ಮತ್ತು ಶೇಖರಿಸಲಾಗುತ್ತದೆ.
06:52 r21, r22, r23 ಮತ್ತು r24 ರ ಮೌಲ್ಯಗಳನ್ನು r4, r5, r6 ಮತ್ತು r7 ರ ಡಮ್ಮಿ ವೇರಿಯೇಬಲ್ ಗಳಲ್ಲಿ ಶೇಖರಿಸಲಾಗುತ್ತದೆ.
07:04 A ಯು W ನ ಕಾಂಪ್ಲಿಮೆಂಟ್ ಆಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

ನಾವೀಗ ಮೊದಲ ಸಮೀಕರಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ್ದೇವೆ.

07:12 ನಂತರ ನಾವು ಎರಡು ಲೆಫ್ಟ್ ಶಿಫ್ಟ್ ಅಪರೇಶನ್ ಗಳನ್ನು ಮಾಡಿ ಮೌಲ್ಯವನ್ನು r30 ರಲ್ಲಿ ಶೇಖರಿಸಲಿದ್ದೇವೆ.

ಹೀಗೆ, r30 ರ ಮೂರನೇ ಬಿಟ್, A ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

07:24 'reload' ಸಬ್ ರೂಟೀನ್, r0, r1, r2, r3, r4, r5, r6 ಮತ್ತು r7 ಮೌಲ್ಯಗಳನ್ನು ಇದರ ಕಾಪಿಗಳಿಂದ ರೀಲೋಡ್ ಮಾಡುತ್ತದೆ.
07:36 ಹಿಂದಿನ ಅಪರೇಶನ್ ಗಳ ವೇಳೆ ಅವು ಬದಲಾಗಿರಬಹುದು.
07:41 B ಗೆ ಲಾಜಿಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು r0 ಯಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿದೆ.
07:47 r0 ಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಮೂರು ಬಾರಿ ಲೆಫ್ಟ್ ಶಿಫ್ಟ್ ಮಾಡಿ r30 ರಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿದೆ.
07:54 ಈಗ, r30 ರ ನಾಲ್ಕನೇ ಬಿಟ್, B ಯ ಫಲಿತಾಂಶವನ್ನು ಹಿಡಿದಿಡುತ್ತದೆ.
08:00 C ಗೆ ಲಾಜಿಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು r0 ಯಲ್ಲಿ ಫಲಿತಾಂಶವನ್ನು ಶೇಖರಿಸಲಾಗಿದೆ.
08:06 r0 ರಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ನಾಲ್ಕು ಬಾರಿ ಲೆಫ್ಟ್ ಶಿಫ್ಟ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು r30 ರಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿದೆ.
08:13 ಈಗ r30 ರ ಐದನೇ ಬಿಟ್, C ಯ ಫಲಿತಾಂಶವನ್ನು ಹಿಡಿದಿಡುತ್ತದೆ.
08:19 D ಗೆ ಲಾಜಿಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು r0 ನಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿದೆ.
08:25 r0 ಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಐದು ಬಾರಿ ಲೆಫ್ಟ್ ಶಿಫ್ಟ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು r30 ರಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿದೆ.
08:32 ಈಗ r30 ರ ಆರನೇ ಬಿಟ್, D ಯ ಫಲಿತಾಂಶವನ್ನು ಹಿಡಿದಿಡುತ್ತದೆ.
08:38 ಅಂತಿಮವಾಗಿ, r30 ರಲ್ಲಿ ಶೇಖರಿಸಲಾಗಿರುವ ಮೌಲ್ಯವನ್ನು ಡಿಸ್ಪ್ಲೇಗಾಗಿ PORTD ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
08:46 ಕೋಡ್ ಅನ್ನು home slash spoken slash Assembly ಫೋಲ್ಡರ್ ನಲ್ಲಿ combination.asm ಆಗಿ ಸೇವ್ ಮಾಡಿ.
08:55 terminal ಗೆ ಮರಳಿ.
08:58 avra space combination.asm ಎಂದು ಟೈಪ್ ಮಾಡಿ Enter ಒತ್ತಿ.
09:05 ಇದು ಕೋಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು combination.hex ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ನಾವು ಟರ್ಮಿನಲ್ ಅನ್ನು ತೆರವುಗೊಳಿಸೋಣ.

09:14 ಅಪ್ ಲೋಡ್ ಮಾಡಲು, ಹಿಂದಿನ ಕಮಾಂಡ್ ಪಡೆಯುವುದಕ್ಕಾಗಿ ಅಪ್ ಆರೋ ಒತ್ತಿ.
09:19 ಈಗ, ಇಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಫೈಲ್ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಿ ಮತ್ತು Enter ಒತ್ತಿ.
09:26 ನೀವು ಟ್ರುತ್ ಟೇಬಲ್ ಅನ್ನು ಸೆವೆನ್ ಸೆಗ್ಮೆಂಟ್ ಡಿಸ್ಪ್ಲೇ ಯಲ್ಲಿ ತೋರಿಸಿರುವ ಔಟ್ಪುಟ್ ಜೊತೆ ಪರಿಶೀಲಿಸಬಹುದು.
09:34 ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಪಾಸ್ (Pause) ಮಾಡಿ ಮತ್ತು ಕೆಳಗಿನ ಅಸೈನ್ ಮೆಂಟ್ ಮಾಡಿ.
09:38 W, X, Y ಮತ್ತು Z ನ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಿ ಮತ್ತು ಟ್ರುತ್ ಟೇಬಲ್ ನಲ್ಲಿ ವಿವಿಧ ಸಾಲುಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.
09:46 ಇದರೊಂದಿಗೆ ನಾವು ಈ ಟ್ಯುಟೋರಿಯಲ್ ನ ಕೊನೆಗೆ ತಲುಪಿದ್ದೇವೆ. ನಾವೀಗ ಸಂಕ್ಷೇಪಿಸೋಣ.
09:52 ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು: assembly ಯಲ್ಲಿ AND, OR ಮತ್ತು XOR ಅಪರೇಶನ್ ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು,
10:01 ಸರಳ ಕಾಂಬಿನೇಶನಲ್ ಲಾಜಿಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ಕಲಿತೆವು.
10:05 ಈ ಕೆಳಗಿನ ಲಿಂಕ್ ನಲ್ಲಿ ಇರುವ ವೀಡಿಯೊ, ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಸಂಕ್ಷೇಪಿಸುತ್ತದೆ. ದಯವಿಟ್ಟು ಇದನ್ನು ಡೌನ್ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ವೀಕ್ಷಿಸಿ.
10:13 ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಾಜೆಕ್ಟ್ ತಂಡವು ಕಾರ್ಯಾಗಾರಗಳನ್ನು ನಡೆಸುತ್ತದೆ ಮತ್ತು ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ದಯವಿಟ್ಟು ನಮಗೆ ಪತ್ರ ಬರೆಯಿರಿ.

10:23 ನಿಮ್ಮ ಟೈಮ್ಡ್ ಕ್ವೆರಿಯನ್ನು ಈ ಫೋರಂ ನಲ್ಲಿ ಪೋಸ್ಟ್ ಮಾಡಿ.
10:27 ‘ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್’ ಪ್ರೊಜೆಕ್ಟ್, NMEICT, MHRD, ಭಾರತ ಸರ್ಕಾರದ ನೆರವು ಪಡೆದಿದೆ.

ಈ ಮಿಷನ್ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಈ ಲಿಂಕ್ ನಲ್ಲಿ ಲಭ್ಯ.

10.38 ಈ ಸ್ಕ್ರಿಪ್ಟ್ ನ ಅನುವಾದಕರು ಮಂಗಳೂರಿನಿಂದ ಮೆಲ್ವಿನ್, ಮತ್ತು ಧ್ವನಿ ---------- .

ಧನ್ಯವಾದಗಳು.

Contributors and Content Editors

Melkamiyar, Sandhya.np14