Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
ɭɤɚɡɵɜɚɟɬ fpath, ɡɚɞɚɟɬɫɹ ɜ ɩɟɪɟɦɟɧɧɨɣ len. ȿɫɥɢ fpath ɪɚɜɟɧ NULL, ɬɨ
ɦɚɫɫɢɜ ɛɭɞɟɬ ɪɚɡɦɟɳɟɧ ɞɢɧɚɦɢɱɟɫɤɢ. (ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɦɚɫɫɢɜ ɞɨɥɠɟɧ ɛɵɬɶ ɨɫɜɨɛɨɠɞɟɧ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɮɭɧɤɰɢɢ free()). Ɏɭɧɤɰɢɹ _fullpath() ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ fpath ɢɥɢ NULL ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ. ɉɪɨɬɨɬɢɩ ɮɭɧɤɰɢɢ
ɨɩɢɫɚɧ ɜ stdlib.h.
ɉɪɢɦɟɪ 3.13. ɉɨɥɭɱɟɧɢɟ ɩɨɥɧɨɝɨ ɩɭɬɢ.
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main(void) {
char fpath[80];
setlocale(LC_ALL, "RUS");
// ɦɟɧɹɟɦ ɤɚɬɚɥɨɝ
ɧɚ INCLUDE
_fullpath (fpath, "\\INCLUDE", 80);
printf("ɉɨɥɧɵɣ ɩɭɬɶ: %s\n", fpath);
return 0;
}
Ɏɭɧɤɰɢɹ void _makepath(char *pname, const char
*drive, const char *directory, const char *fname, const
char *extension) ɤɨɧɫɬɪɭɢɪɭɟɬ ɩɨɥɧɵɣ ɩɭɬɶ ɢɡ ɷɥɟɦɟɧɬɨɜ, ɡɚɞɚɧɧɵɯ ɩɚ-
ɪɚɦɟɬɪɚɦɢ ɮɭɧɤɰɢɢ, ɢ ɩɨɦɟɳɚɟɬ ɪɟɡɭɥɶɬɚɬ ɜ ɦɚɫɫɢɜ, ɧɚ ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɩɚɪɚɦɟɬɪ pname. ɂɦɹ ɞɢɫɤɚ ɡɚɞɚɟɬɫɹ ɫɬɪɨɤɨɣ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ drive. Ʉɚɬɚɥɨɝ (ɢ ɥɸɛɨɣ ɩɨɞɤɚɬɚɥɨɝ) ɡɚɞɚɟɬɫɹ ɫ ɩɨɦɨɳɶɸ ɫɬɪɨɤɢ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ
directory. ɇɚ ɢɦɹ ɮɚɣɥɚ ɭɤɚɡɵɜɚɟɬ
ɩɚɪɚɦɟɬɪ
fname, ɚ ɧɚ ɪɚɫɲɢɪɟɧɢɟ – extension.
Ʌɸɛɚɹ ɢɡ ɷɬɢɯ ɫɬɪɨɤ ɦɨɠɟɬ ɛɵɬɶ ɩɭɫɬɨɣ.
ɉɪɢɦɟɪ 3.14. ɉɨɥɭɱɟɧɢɟ ɫɨɫɬɚɜɥɹɸɳɢɯ ɩɨɥɧɨɝɨ ɩɭɬɢ.
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main(void) {
char fpath[80];
char fname[9];
char dir[64];
char drive[3];
char ext[5];
setlocale(LC_ALL, "RUS");
// ɤɨɧɫɬɪɭɢɪɭɟɦ ɩɨɥɧɵɣ ɩɭɬɶ
_makepath(fpath, "ȼ", "MYDIR", "MYFILE", "TXT");
printf("%s\n", fpath);
// ɪɚɡɞɟɥɹɟɦ ɩɭɬɶ ɧɚ ɫɨɫɬɚɜɥɹɸɳɢɟ _splitpath(fpath,
drive, dir, fname, ext);
printf ("%s %s %s %s\n", drive, dir, fname, ext);
return 0;
}
91
ɂɫɩɨɥɶɡɨɜɚɧɧɚɹ ɜ ɩɨɫɥɟɞɧɟɦ ɩɪɢɦɟɪɟ ɮɭɧɤɰɢɹ splitpath() ɪɚɡɞɟɥɹɟɬ
ɩɨɥɧɵɣ ɩɭɬɶ, ɡɚɞɚɧɧɵɣ ɜ ɫɬɪɨɤɟ fpath, ɧɚ ɫɨɫɬɚɜɥɹɸɳɢɟ: ɫɢɦɜɨɥ ɞɢɫɤɚ ɩɨɦɟɳɚɟɬɫɹ ɜ ɫɬɪɨɤɭ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɩɚɪɚɦɟɬɪ drive, ɢɦɹ ɤɚɬɚɥɨɝɚ ɢ ɜɯɨɞɹɳɢɯ ɜ ɧɟɝɨ ɩɨɞɤɚɬɚɥɨɝɨɜ ɩɨɦɟɳɚɸɬɫɹ ɜ ɫɬɪɨɤɭ directory, ɢɦɹ ɮɚɣɥɚ – ɜ ɫɬɪɨɤɭ fname, ɚ ɪɚɫɲɢɪɟɧɢɟ – ɜ ɫɬɪɨɤɭ extension. Ɇɢɧɢɦɚɥɶɧɵɟ ɪɚɡɦɟɪɵ
ɦɚɫ-
ɫɢɜɨɜ, ɧɚ ɤɨɬɨɪɵɟ ɭɤɚɡɵɜɚɸɬ ɷɬɢ ɩɚɪɚɦɟɬɪɵ, ɩɪɟɞɫɬɚɜɥɟɧɵ ɜ ɬɚɛɥ. 3.3.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.3
ɉɚɪɚɦɟɬɪɵ ɮɭɧɰɢɢ splitpath
Ɋɚɡɦɟɪ
ɉɚɪɚɦɟɬɪ
ɂɦɹ ɤɨɧɫɬɚɧɬɵ
DOS Windows
drive 3 3 _MAX_DRIVE
directory 66 256 _MAX_DIR
fname 9 256 _MAX_FILE
extension 5 256 _MAX_EXT
3.2.3. Ɋɚɛɨɬɚ ɫ ɮɚɣɥɚɦɢ
ɇɚ ɭɪɨɜɧɟ Ⱥɫɫɟɦɛɥɟɪɚ ɨɩɟɪɚɰɢɨɧɧɵɟ ɫɢɫɬɟɦɵ MS DOS ɢ Windows ɩɨɞɞɟɪɠɢɜɚɸɬ ɮɚɣɥɨɜɵɟ ɨɩɟɪɚɰɢɢ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɣ ɩɪɟɪɵɜɚɧɢɹ 21h. ȼ Ⱥɫɫɟɦɛɥɟɪɟ Linux ɨɩɟɪɚɰɢɢ ɫ ɮɚɣɥɚɦɢ ɪɟɚɥɢɡɭɸɬɫɹ ɱɟɪɟɡ ɫɢɫɬɟɦɧɨɟ ɩɪɟɪɵɜɚɧɢɟ 80h. ɉɪɨɝɪɚɦɦɧɚɹ ɪɟɚɥɢɡɚɰɢɹ ɜ Ⱥɫɫɟɦɛɥɟɪɟ ɞɨɫɬɚɬɨɱɧɨ ɩɨɞɪɨɛɧɨ ɪɚɫɫɦɨɬɪɟɧɚ ɜ ɥɢɬɟɪɚɬɭɪɟ [2, 6]. Ɇɵ ɠɟ ɭɞɟɥɢɦ ɨɫɨɛɨɟ ɜɧɢɦɚɧɢɟ ɩɪɨɝɪɚɦɦɧɨɣ ɪɟɚɥɢɡɚɰɢɢ ɨɩɟɪɚɰɢɣ ɫ ɮɚɣɥɚɦɢ ɜ ɋɢ.
Ɍɢɩɨɜɵɟ
ɨɩɟɪɚɰɢɢ ɫ ɮɚɣɥɚɦɢ ɫɥɟɞɭɸɳɢɟ:
ɫɨɡɞɚɧɢɟ ɧɨɜɨɝɨ ɮɚɣɥɚ;
ɨɬɤɪɵɬɢɟ ɫɭɳɟɫɬɜɭɸɳɟɝɨ ɮɚɣɥɚ;
ɡɚɩɢɫɶ ɜ ɮɚɣɥ;
ɱɬɟɧɢɟ ɢɡ ɮɚɣɥɚ;
ɡɚɤɪɵɬɢɟ ɮɚɣɥɚ.
Ⱦɥɹ ɪɚɛɨɬɵ ɫ ɮɚɣɥɚɦɢ ɩɨɞɤɥɸɱɢɬɟ ɜ ɧɚɱɚɥɟ ɩɪɨɝɪɚɦɦɵ ɡɚɝɨɥɨɜɨɱɧɵɣ
ɮɚɣɥ <stdio.h>.
ȼ ɋɢ ɨɛɪɚɳɟɧɢɟ ɤ ɮɚɣɥɚɦ ɩɪɨɢɡɜɨɞɢɬɫɹ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɢ.
ɍɤɚɡɚɬɟɥɶ ɮɚɣɥɚ – ɷɬɨ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɭɤɬɭɪɭ ɬɢɩɚ FILE,
ɤɨɬɨɪɚɹ ɫɨɞɟɪɠɢɬ ɫɜɟɞɟɧɢɹ ɨ ɮɚɣɥɟ (ɢɦɹ ɮɚɣɥɚ, ɩɨɥɨɠɟɧɢɟ ɬɟɤɭɳɟɣ ɩɨɡɢɰɢɢ ɜ ɮɚɣɥɟ ɢ ɬ. ɩ.).
ɍɤɚɡɚɬɟɥɶ ɮɚɣɥɚ ɨɩɪɟɞɟɥɹɟɬ ɤɨɧɤɪɟɬɧɵɣ ɮɚɣɥ ɢ ɩɟɪɟɞɚɟɬɫɹ ɜ ɩɨɬɨɤ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɮɭɧɤɰɢɣ ɜɜɨɞɚ/ɜɵɜɨɞɚ.
Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ-ɭɤɚɡɚɬɟɥɹ ɮɚɣɥɚ ɩɪɨɢɡɜɨɞɢɬɫɹ ɬɚɤ:
FILE *fp;
92
Ɋɚɫɫɦɨɬɪɢɦ, ɤɚɤ ɩɪɨɢɡɜɨɞɹɬɫɹ ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɜɵɲɟ ɨɩɟɪɚɰɢɢ ɫ ɮɚɣɥɚɦɢ ɜ
ɩɪɨɝɪɚɦɦɚɯ ɋɢ.
Ⱦɥɹ ɫɨɡɞɚɧɢɹ ɢ ɨɬɤɪɵɬɢɹ ɮɚɣɥɚ ɢɫɩɨɥɶɡɭɟɬɫɹ ɮɭɧɤɰɢɹ fopen, ɤɨɬɨɪɚɹ
ɨɬɤɪɵɜɚɟɬ (ɢɥɢ ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ, ɫɨɡɞɚɟɬ) ɮɚɣɥ.
ɉɪɨɬɨɬɢɩ ɮɭɧɤɰɢɢ fopen():
FILE *fopen(const char *ɢɦɹ_ɮɚɣɥɚ,
const char *ɪɟɠɢɦ);
ɝɞɟ ɢɦɹ_ɮɚɣɥɚ – ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɨɤɭ ɫɢɦɜɨɥɨɜ, ɩɪɟɞɫɬɚɜɥɹɸɳɭɸ ɫɨɛɨɣ ɞɨɩɭɫɬɢɦɨɟ ɢɦɹ ɮɚɣɥɚ, ɜ ɤɨɬɨɪɨɟ ɬɚɤɠɟ ɦɨɠɟɬ ɜɯɨɞɢɬɶ
ɫɩɟɰɢɮɢɤɚɰɢɹ ɩɭɬɢ ɤ ɷɬɨɦɭ
ɮɚɣɥɭ;
ɪɟɠɢɦ – ɨɩɪɟɞɟɥɹɟɬ, ɤɚɤɢɦ ɨɛɪɚɡɨɦ (ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɤɚɤɨɣ ɨɩɟɪɚɰɢɢ) ɮɚɣɥ
ɛɭɞɟɬ ɨɬɤɪɵɬ (ɫɦ. ɬɚɛɥ. 3.4).
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.4
Ɋɟɠɢɦɵ ɞɥɹ ɮɭɧɤɰɢɢ fopen
Ɋɟɠɢɦ ɉɨɹɫɧɟɧɢɟ
r Ɉɬɤɪɵɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɞɥɹ ɱɬɟɧɢɹ
w Ɉɬɤɪɵɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɞɥɹ ɡɚɩɢɫɢ
a Ⱦɨɩɨɥɧɢɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ
rb
wb
ab
Ɉɬɤɪɵɬɶ ɞɜɨɢɱɧɵɣ ɮɚɣɥ ɞɥɹ ɱɬɟɧɢɹ
ɋɨɡɞɚɬɶ ɞɜɨɢɱɧɵɣ ɮɚɣɥ ɞɥɹ ɡɚɩɢɫɢ
Ⱦɨɩɨɥɧɢɬɶ ɞɜɨɢɱɧɵɣ ɮɚɣɥ
r+ Ɉɬɤɪɵɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɞɥɹ ɱɬɟɧɢɹ/ɡɚɩɢɫɢ
w+ ɋɨɡɞɚɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɞɥɹ ɱɬɟɧɢɹ/ɡɚɩɢɫɢ
a+
Ⱦɨɩɨɥɧɢɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɢɥɢ ɫɨɡɞɚɬɶ ɬɟɤɫɬɨɜɵɣ ɮɚɣɥ ɞɥɹ
Ɋɚɫɫɦɨɬɪɢɦ ɩɪɢɦɟɪ ɪɚɛɨɬɵ ɫ ɮɚɣɥɨɦ.
ɉɪɢɦɟɪ 3.15. Ɂɚɩɢɫɶ ɜ ɮɚɣɥ.
#include < stdio.h >
#include <locale.h>
int main (void) {
setlocale(LC_ALL, "RUS");
// ɉɟɪɟɦɟɧɧɚɹ – ɭɤɚɡɚɬɟɥɶ ɧɚ ɮɚɣɥɨɜɭɸ ɫɬɪɭɤɬɭɪɭ
//
FILE *f;
// Ɉɬɤɪɵɬɢɟ ɮɚɣɥɚ ɧɚ ɡɚɩɢɫɶ
f=fopen ("myfile.txt","w");
ɱɬɟɧɢɹ/ɡɚɩɢɫɢ
93
// ɉɪɨɜɟɪɤɚ ɧɚ ɨɲɢɛɤɢ
if (f == NULL) printf ("ȼɨɡɧɢɤɥɚ ɨɲɢɛɤɚ\ɩ");
else printf ("\n");
//Ɂɚɩɢɫɶ ɞɚɧɧɵɯ ɜ ɮɚɣɥ
fprintf (f, "ɉɪɨɢɡɜɨɥɶɧɵɣ ɬɟɤɫɬ");
printf ("Ɂɚɩɢɫɶ ɜ ɮɚɣɥ ɜɵɩɨɥɧɟɧɚ^");
// Ɂɚɤɪɵɬɢɟ ɮɚɣɥɚ
fclose (f);
return 0; }
Ɏɭɧɤɰɢɹ fclose() ɡɚɤɪɵɜɚɟɬ ɩɨɬɨɤ, ɱɟɪɟɡ ɤɨɬɨɪɵɣ ɩɪɨɢɡɜɨɞɢɥɢɫɶ ɨɩɟ-
ɪɚɰɢɢ ɱɬɟɧɢɹ/ɡɚɩɢɫɢ ɜ ɮɚɣɥ, ɨɬɤɪɵɬɵɣ ɪɚɧɟɟ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ fopen().
ɉɪɨɬɨɬɢɩ ɮɭɧɤɰɢɢ fclose():
int fclose(FILE *fptr);
ɝɞɟ fptr – ɭɤɚɡɚɬɟɥɶ ɮɚɣɥɚ, ɜɨɡɜɪɚɳɟɧɧɵɣ
ɩɨɫɥɟ ɜɵɡɨɜɚ fopen().
ȿɫɥɢ ɮɭɧɤɰɢɹ fclose ɜɟɪɧɭɥɚ ɧɨɥɶ, ɷɬɨ ɨɡɧɚɱɚɟɬ ɭɫɩɟɲɧɭɸ ɨɩɟɪɚɰɢɸ
ɡɚɤɪɵɬɢɹ. ȼ ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɜɨɡɜɪɚɳɚɟɬɫɹ ɤɨɧɫɬɚɧɬɚ EOF. ɍɡɧɚɬɶ ɩɪɢɱɢɧɭ
ɨɲɢɛɤɢ ɦɨɠɧɨ, ɢɫɩɨɥɶɡɭɹ ɮɭɧɤɰɢɸ ferror().
Ɉɲɢɛɤɚ ɩɪɢ ɜɵɩɨɥɧɟɧɢɢ fclose() ɩɪɨɢɫɯɨɞɢɬ ɬɨɝɞɚ, ɤɨɝɞɚ ɞɢɫɤ ɛɵɥ
ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ ɭɞɚɥɟɧ ɢɥɢ ɧɚ ɞɢɫɤɟ ɧɟ ɨɫɬɚɥɨɫɶ ɫɜɨɛɨɞɧɨɝɨ ɦɟɫɬɚ.
ɉɪɢɦɟɪ 3.16. ɉɨɥɭɱɟɧɢɟ ɤɨɞɚ ɨɲɢɛɤɢ.
int err = fclose(fp);
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɱɬɨ
ɜ ɩɪɟɞɵɞɭɳɟɦ ɩɪɢɦɟɪɟ ɦɵ ɜɵɡɜɚɥɢ fclose ɛɟɡ
ɩɨɥɭɱɟɧɢɹ ɤɨɞɚ ɜɨɡɜɪɚɬɚ. ɗɬɨ ɬɨɠɟ ɜɨɡɦɨɠɧɨ, ɧɨ ɩɪɢ ɷɬɨɦ ɦɵ ɬɟɪɹɟɦ ɫɜɟɞɟɧɢɹ
ɨ ɜɨɡɦɨɠɧɨɣ ɨɲɢɛɤɟ ɢ ɧɟ ɢɦɟɟɦ ɜɨɡɦɨɠɧɨɫɬɢ ɨɛɪɚɛɨɬɚɬɶ ɟɟ.
Ɂɚɩɢɫɶ ɫɢɦɜɨɥɨɜ ɩɪɨɢɡɜɨɞɢɬɫɹ ɮɭɧɤɰɢɟɣ putc(), ɤɨɬɨɪɚɹ ɡɚɩɢɫɵɜɚɟɬ
ɫɢɦɜɨɥɵ ɜ ɮɚɣɥ, ɩɪɟɞɜɚɪɢɬɟɥɶɧɨ ɨɬɤɪɵɬɵɣ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ fopen() ɜ
ɪɟɠɢɦɟ ɡɚɩɢɫɢ. ɉɪɨɬɨɬɢɩ ɷɬɨɣ ɮɭɧɤɰɢɢ:
int putc(int ch, FILE * fptr );
fptr – ɷɬɨ ɭɤɚɡɚɬɟɥɶ ɮɚɣɥɚ, ɜɨɡɜɪɚɳɟɧɧɵɣ ɮɭɧɤɰɢɟɣ fopen(),
ɝɞɟ
ch – ɜɵɜɨɞɢɦɵɣ ɫɢɦɜɨɥ.
ȿɫɥɢ ɮɭɧɤɰɢɹ putc() ɡɚɜɟɪɲɢɥɚɫɶ ɭɫɩɟɲɧɨ, ɬɨ ɜɨɡɜɪɚɳɚɟɬɫɹ ɡɚɩɢɫɚɧɧɵɣ ɫɢɦɜɨɥ, ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɨɡɜɪɚɳɚɟɬɫɹ EOF.
Ɏɭɧɤɰɢɹ getc() ɱɢɬɚɟɬ ɫɢɦɜɨɥ ɢɡ ɮɚɣɥɚ, ɤɨɬɨɪɵɣ ɫ ɩɨɦɨɳɶɸ fopen()
ɭɠɟ ɨɬɤɪɵɬ ɜ ɪɟɠɢɦɟ ɞɥɹ ɱɬɟɧɢɹ. ɉɪɨɬɨɬɢɩ ɷɬɨɣ ɮɭɧɤɰɢɢ:
int getc(FILE * fptr);
ɝɞɟ fptr – ɷɬɨ ɭɤɚɡɚɬɟɥɶ ɮɚɣɥɚ, ɢɦɟɸɳɢɣ ɬɢɩ
FILE ɢ ɜɨɡɜɪɚɳɟɧɧɵɣ ɮɭɧɤ-
ɰɢɟɣ fopen().
ɉɪɢ ɞɨɫɬɢɠɟɧɢɢ ɤɨɧɰɵ ɮɚɣɥɚ ɮɭɧɤɰɢɹ getc() ɜɨɡɜɪɚɳɚɟɬ EOF. ɉɨɷɬɨɦɭ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɪɨɱɢɬɚɬɶ ɫɢɦɜɨɥɵ ɞɨ ɤɨɧɰɚ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ, ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
do {
ch = getc(fp);
} while(ch!=EOF);
94
Ɏɭɧɤɰɢɹ getc() ɜɨɡɜɪɚɳɚɟɬ EOF ɢ ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ, ɤɨɬɨɪɭɸ ɦɨɠɧɨ
ɨɩɪɟɞɟɥɢɬɶ ɫ ɩɨɦɨɳɶɸ ferror().
ɑɬɟɧɢɟ ɢ ɡɚɩɢɫɶ ɫɬɪɨɤ ɩɪɨɢɡɜɨɞɢɬɫɹ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɣ fgets() ɢ
fputs(), ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ.
ɉɪɨɬɨɬɢɩɵ ɮɭɧɤɰɢɣ fgets() ɢ fputs():
int fputs(const char * str, FILE * fptr);
char *fgets(char *str, int length, FILE * fptr);
Ɏɭɧɤɰɢɹ fputs() ɩɢɲɟɬ ɜ ɡɚɞɚɧɧɵɣ ɩɨɬɨɤ ɫɬɪɨɤɭ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɩɟɪɟɦɟɧɧɚɹ str. ȼ ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɷɬɚ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ EOF.
Ɏɭɧɤɰɢɹ
fgets() ɱɢɬɚɟɬ ɢɡ ɡɚɞɚɧɧɨɝɨ ɩɨɬɨɤɚ ɫɬɪɨɤɭ, ɢ ɞɟɥɚɟɬ ɷɬɨ ɞɨ ɬɟɯ
ɩɨɪ, ɩɨɤɚ ɧɟ ɛɭɞɟɬ ɩɪɨɱɢɬɚɧ ɫɢɦɜɨɥ ɧɨɜɨɣ ɫɬɪɨɤɢ ɢɥɢ ɤɨɥɢɱɟɫɬɜɨ ɩɪɨɱɢɬɚɧɧɵɯ
ɫɢɦɜɨɥɨɜ ɧɟ ɫɬɚɧɟɬ ɪɚɜɧɵɦ length-1. ȿɫɥɢ ɛɵɥ ɩɪɨɱɢɬɚɧ ɪɚɡɞɟɥɢɬɟɥɶ ɫɬɪɨɤ,
ɨɧ ɬɚɤɠɟ ɡɚɩɢɫɵɜɚɟɬɫɹ ɜ ɫɬɪɨɤɭ, ɱɟɦ ɮɭɧɤɰɢɹ fgets() ɨɬɥɢɱɚɟɬɫɹ ɨɬ ɮɭɧɤɰɢɢ gets(). ɉɨɥɭɱɟɧɧɚɹ ɜ ɪɟɡɭɥɶɬɚɬɟ ɫɬɪɨɤɚ ɛɭɞɟɬ ɨɤɚɧɱɢɜɚɬɶɫɹ ɫɢɦɜɨɥɨɦ
ɤɨɧɰɚ ɫɬɪɨɤɢ '0'. ɉɪɢ ɭɫɩɟɲɧɨɦ ɡɚɜɟɪɲɟɧɢɢ ɪɚɛɨɬɵ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɫɬɪɨɤɭ str, ɚ ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ – ɩɭɫɬɨɣ ɭɤɚɡɚɬɟɥɶ (null).
ɉɪɢ ɪɚɫɫɦɨɬɪɟɧɢɢ ɮɚɣɥɨɜɵɯ ɮɭɧɤɰɢɣ ɜɜɨɞɚ-ɜɵɜɨɞɚ ɦɵ ɨɫɨɛɨ ɨɬɦɟɱɚɥɢ,
ɱɬɨ ɜɫɟ ɮɭɧɤɰɢɢ ɜɨɡɜɪɚɳɚɸɬ ɫɩɟɰɢɚɥɶɧɵɣ ɤɨɞ ɜ ɫɥɭɱɚɟ ɜɨɡɧɢɤɧɨɜɟɧɢɹ ɨɲɢɛɤɢ.
ɂɞɟɧɬɢɮɢɰɢɪɨɜɚɬɶ ɨɲɢɛɤɭ ɩɨɡɜɨɹɥɟɬ ɮɭɧɤɰɢɹ ferror. ɉɪɨɬɨɬɢɩ ɷɬɨɣ ɮɭɧɤɰɢɢ ɫɥɟɞɭɸɳɢɣ:
int ferror(FILE * fptr);
ɝɞɟ fptr
– ɭɤɚɡɚɬɟɥɶ ɮɚɣɥɚ.
Ɏɭɧɤɰɢɹ ferror ɜɨɡɜɪɚɳɚɟɬ true, ɟɫɥɢ ɩɪɢ ɩɨɫɥɟɞɧɟɣ ɨɩɟɪɚɰɢɢ ɫ ɮɚɣɥɨɦ ɩɪɨɢɡɨɲɥɚ ɨɲɢɛɤɚ; ɜ ɩɪɨɬɢɜɧɨɦ ɠɟ ɫɥɭɱɚɟ ɨɧɚ ɜɨɡɜɪɚɳɚɟɬ false. Ɍɚɤ ɤɚɤ
ɞɥɹ ɤɚɠɞɨɣ ɤɨɧɤɪɟɬɧɨɣ ɨɩɟɪɚɰɢɢ ɫ ɮɚɣɥɨɦ ɡɚɞɚɟɬɫɹ ɫɨɛɫɬɜɟɧɧɨɟ ɭɫɥɨɜɢɟ
ɨɲɢɛɤɢ, ɬɨ ɩɨɫɥɟ ɤɚɠɞɨɣ ɬɚɤɨɣ ɨɩɟɪɚɰɢɢ ɫɥɟɞɭɟɬ ɫɪɚɡɭ ɜɵɡɵɜɚɬɶ ferror,
ɢɧɚɱɟ ɫɜɟɞɟɧɢɹ ɨɛ ɨɲɢɛɤɟ ɛɭɞɭɬ ɩɨɬɟɪɹɧɵ.
ɉɪɢɦɟɪ 3.17.
Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɤɢ ɜɜɨɞɚ.
ch = getc(in); if(ferror(in) ɞɟɣɫɬɜɢɟ);
3.3. ɉɨɪɬɵ ɜɜɨɞɚ-ɜɵɜɨɞɚ
3.3.1. Ɉɛɳɢɟ ɫɜɟɞɟɧɢɹ ɨ ɩɨɪɬɚɯ ɜɜɨɞɚ-ɜɵɜɨɞɚ
ɉɨɪɬɵ (ɢɧɬɟɪɮɟɣɫɵ) ɢɫɩɨɥɶɡɭɸɬɫɹ ɞɥɹ ɩɨɞɤɥɸɱɟɧɢɹ ɜɧɟɲɧɢɯ ɭɫɬɪɨɣɫɬɜ ɤ
ɤɨɦɩɶɸɬɟɪɭ. Ɋɚɡɥɢɱɚɸɬ ɩɚɪɚɥɥɟɥɶɧɵɣ, ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬɵ, ɢɧɮɪɚɤɪɚɫɧɵɣ ɩɨɪɬ ɢ ɬ. ɞ. ɉɟɪɟɱɟɧɶ ɪɚɡɧɨɜɢɞɧɨɫɬɟɣ ɩɨɪɬɨɜ, ɢɫɩɨɥɶɡɭɟɦɵɯ ɜ ɤɨɦɩɶɸɬɟɪɚɯ, ɩɨɫɬɨɹɧɧɨ ɪɚɫɬɟɬ ɩɨ ɦɟɪɟ ɩɨɹɜɥɟɧɢɹ ɧɨɜɵɯ ɬɟɯɧɨɥɨɝɢɣ ɢ ɩɪɨɬɨɤɨɥɨɜ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ.
ɇɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɢɧɬɟɪɮɟɣɫɵ ɞɥɹ ɤɨɦɩɶɸɬɟɪɨɜ ɧɟɩɪɟɪɵɜɧɨ ɪɚɡɜɢɜɚɸɬɫɹ, ɟɫɬɶ ɞɜɚ ɜɢɞɚ
ɩɨɪɬɨɜ – ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ (COM) ɢ ɩɚɪɚɥɥɟɥɶɧɵɣ (LPT), ɤɨɬɨɪɵɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɞɨ ɫɢɯ ɩɨɪ ɢ ɧɟ ɬɟɪɹɸɬ ɫɜɨɟɣ ɩɨɩɭɥɹɪɧɨɫɬɢ. ɗɬɨ ɨɛɭɫɥɨɜɥɟɧɨ ɨɬɪɚɛɨɬɚɧɧɨɣ ɝɨɞɚɦɢ ɬɟɯɧɨɥɨɝɢɟɣ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ, ɧɚɥɢɱɢɟɦ ɩɨɞɪɨɛɧɨɣ
ɞɨɤɭɦɟɧɬɚɰɢɢ, ɜɨɡɦɨɠɧɨɫɬɶ ɪɚɛɨɬɵ ɫ ɪɚɡɧɨɨɛɪɚɡɧɵɦ ɨɛɨɪɭɞɨɜɚɧɢɟɦ (ɜɤɥɸɱɚɹ
95
ɫɩɟɰɢɮɢɱɟɫɤɢɟ ɩɪɨɦɵɲɥɟɧɧɵɟ ɭɫɬɚɧɨɜɤɢ), ɚ ɬɚɤɠɟ ɧɚɥɢɱɢɟɦ ɛɨɥɶɲɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɨɛɨɪɭɞɨɜɚɧɢɹ, ɜɵɩɭɳɟɧɧɨɝɨ ɪɚɧɟɟ. Ʉɪɨɦɟ COM ɢ LPT, ɜ ɩɨɫɥɟɞɧɢɟ ɝɨɞɵ ɩɨɹɜɢɥɢɫɶ ɬɚɤɢɟ ɢɧɬɟɪɮɟɣɫɵ, ɤɚɤ IrDA (Infrared Data Assotiation – ɢɧɬɟɪɮɟɣɫ ɫɜɹɡɢ, ɨɫɧɨɜɚɧɧɵɣ ɧɚ ɨɬɤɪɵɬɨɦ ɨɩɬɢɱɟɫɤɨɦ ɤɚɧɚɥɟ ɜ ɢɧɮɪɚɤɪɚɫɧɨɦ ɞɢɚɩɚɡɨɧɟ), IEEE 1394 (ɰɢɮɪɨɜɨɣ ɢɧɬɟɪɮɟɣɫ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɭɸ
ɲɢɧɭ), Bluetooth (ɢɧɬɟɪɮɟɣɫ, ɨɫɭɳɟɫɬɜɥɹɸɳɢɣ ɨɛɦɟɧ ɞɚɧɧɵɦɢ ɩɨɫɪɟɞɫɬɜɨɦ
ɛɟɫɩɪɨɜɨɞɧɵɯ ɫɟɬɟɣ), Wi-Fi (Wireless Fidelity – ɜɵɫɨɤɨɫɤɨɪɨɫɬɧɨɣ ɛɟɫɩɪɨɜɨɞɧɵɣ ɢɧɬɟɪɮɟɣɫ ɨɛɦɟɧɚ
ɞɚɧɧɵɦɢ) ɢ ɞɪɭɝɢɟ [3, 7].
Ɍɚɤɢɟ ɢɧɬɟɪɮɟɣɫɵ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ, ɤɚɤ LPT, IrDA, Bluetooth, ɜ ɧɚɫɬɨɹɳɟɟ
ɜɪɟɦɹ ɩɪɚɤɬɢɱɟɫɤɢ ɧɟ ɢɫɩɨɥɶɡɭɸɬɫɹ. ɉɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɢɧɬɟɪɮɟɣɫ COM ɞɨ
ɫɢɯ ɩɨɪ ɩɨɞɞɟɪɠɢɜɚɟɬɫɹ ɤɚɤ ɜ ɩɟɪɫɨɧɚɥɶɧɵɯ ɤɨɦɩɶɸɬɟɪɚɯ, ɬɚɤ ɢ ɜ ɩɪɨɦɵɲɥɟɧɧɵɯ ɭɫɬɪɨɣɫɬɜɚɯ, ɚ ɬɚɤɠɟ ɜ ɨɛɨɪɭɞɨɜɚɧɢɢ ɞɥɹ ɤɨɦɩɶɸɬɟɪɧɵɯ ɫɟɬɟɣ.
Ⱦɨɫɬɭɩ ɤ COM- ɢ LPT-ɩɨɪɬɚɦ ɪɚɧɟɟ ɩɪɨɢɡɜɨɞɢɥɫɹ ɩɨɫɪɟɞɫɬɜɨɦ ɮɭɧɤɰɢɣ
BIOS (ɧɚɩɪɢɦɟɪ, ɜ Windows ɪɚɧɧɢɯ ɜɟɪɫɢɣ – ɞɨ
Windows 98 ɜɤɥɸɱɢɬɟɥɶɧɨ),
ɚɩɩɚɪɚɬɧɵɯ ɩɨɪɬɨɜ, ɚ ɬɚɤɠɟ ɮɭɧɤɰɢɣ API (Application Programming Interface –
ɢɧɬɟɪɮɟɣɫ ɩɪɢɤɥɚɞɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ) ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ.
3.3.2. ɉɚɪɚɥɥɟɥɶɧɵɣ ɩɨɪɬ
ɂɡɭɱɟɧɢɟ ɩɚɪɚɥɥɟɥɶɧɨɝɨ ɩɨɪɬɚ LPT, ɤɚɤ ɧɚɢɛɨɥɟɟ ɩɪɨɫɬɨɝɨ ɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ, ɩɨɡɜɨɥɹɟɬ ɩɨɧɹɬɶ ɨɛɳɢɟ ɩɪɢɧɰɢɩɵ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɩɨɪɬɨɜ
ɜɜɨɞɚ-ɜɵɜɨɞɚ. ɉɨɷɬɨɦɭ ɪɚɫɫɦɨɬɪɟɧɢɟ ɦɵ ɧɚɱɧɟɦ ɢɦɟɧɧɨ ɫ ɧɟɝɨ.
ɉɟɪɟɞɚɱɚ ɞɚɧɧɵɯ ɱɟɪɟɡ LPT-ɩɨɪɬ ɩɪɨɢɡɜɨɞɢɬɫɹ ɩɭɬɟɦ ɩɨɫɵɥɤɢ ɛɚɣɬɚ ɢɧɮɨɪɦɚɰɢɢ ɨɬ ɢɫɬɨɱɧɢɤɚ ɤ ɩɪɢɟɦɧɢɤɭ ɩɨ 8 ɥɢɧɢɹɦ. ȼ ɩɪɨɰɟɫɫɟ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ
ɩɟɪɟɞɚɟɬɫɹ 1 ɛɚɣɬ ɡɚ ɨɞɢɧ ɰɢɤɥ, ɩɪɢ ɷɬɨɦ
ɩɪɢɟɦɧɚɹ ɢ ɩɟɪɟɞɚɸɳɚɹ ɫɬɨɪɨɧɵ ɫɨɨɛɳɚɸɬ ɩɨ ɨɬɞɟɥɶɧɨɣ ɥɢɧɢɢ ɨ ɫɜɨɟɦ ɫɨɫɬɨɹɧɢɢ ɫ ɩɨɦɨɳɶɸ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɯ
ɫɢɝɧɚɥɨɜ: ɤɨɝɞɚ ɭɫɬɪɨɣɫɬɜɨ ɡɚɧɹɬɨ, ɨɧɨ ɜɵɞɚɟɬ ɫɢɝɧɚɥ busy, ɚ ɤɨɝɞɚ ɩɪɨɝɪɚɦɦɚ
ɩɨɞɝɨɬɨɜɢɥɚ ɛɚɣɬ ɞɚɧɧɵɯ ɞɥɹ ɩɟɪɟɞɚɱɢ, ɨɧɚ ɩɟɪɟɫɵɥɚɟɬ ɭɫɬɪɨɣɫɬɜɭ ɫɢɝɧɚɥ
strobe. ɂɦɟɸɬɫɹ ɬɚɤɠɟ ɨɬɞɟɥɶɧɵɟ ɥɢɧɢɢ ɫɜɹɡɢ ɞɥɹ ɤɨɧɬɪɨɥɹ ɩɟɪɟɞɚɜɚɟɦɵɯ
ɞɚɧɧɵɯ, ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɬɫɭɬɫɬɜɢɢ ɛɭɦɚɝɢ (
ɩɪɢ ɨɛɦɟɧɟ ɞɚɧɧɵɦɢ ɫ ɩɪɢɧɬɟɪɨɦ), ɞɥɹ ɩɟɪɟɞɚɱɢ ɫɨɨɛɳɟɧɢɣ ɨɛ ɨɲɢɛɤɚɯ ɢ ɝɨɬɨɜɧɨɫɬɢ ɭɫɬɪɨɣɫɬɜɚ. Ɇɚɤɫɢɦɚɥɶɧɚɹ ɫɤɨɪɨɫɬɶ ɩɟɪɟɞɚɱɢ ɱɟɪɟɡ ɩɚɪɚɥɥɟɥɶɧɵɣ ɢɧɬɟɪɮɟɣɫ ɦɨɠɟɬ ɫɨɫɬɚɜɥɹɬɶ
120–200 Ʉɛɚɣɬ/ɫɟɤ, ɬ. ɟ. ɫɪɚɜɧɢɬɟɥɶɧɨ ɧɟɜɵɫɨɤɚ.
ɇɚɩɪɹɦɭɸ ɨɛɪɚɳɚɬɶɫɹ ɤ LPT-ɩɨɪɬɚɦ ɢɥɢ ɠɟ ɩɨɥɭɱɚɬɶ ɢɡ ɧɢɯ ɡɧɚɱɟɧɢɹ
ɦɨɠɧɨ ɢɡ ɨɛɥɚɫɬɢ ɩɚɦɹɬɢ BIOS.
Ɍɚɤ, ɞɥɹ ɢɧɬɟɪɮɟɣɫɚ LPT1 ɪɟɝɢɫɬɪ ɞɚɧɧɵɯ ɢɦɟɟɬ ɚɞɪɟɫ 378h,
ɪɟɝɢɫɬɪ ɫɨɫɬɨɹɧɢɹ – 379h, ɚ ɪɟɝɢɫɬɪ ɭɩɪɚɜɥɟɧɢɹ – 37Ah. ɉɨɪɬ ɞɚɧɧɵɯ ɫɨɞɟɪɠɢɬ ɞɚɧɧɵɟ
ɞɥɹ ɩɟɪɟɞɚɱɢ ɦɟɠɞɭ ɤɨɦɩɶɸɬɟɪɨɦ ɢ ɭɫɬɪɨɣɫɬɜɨɦ ɢ ɞɨɫɬɭɩɟɧ ɤɚɤ ɞɥɹ ɡɚɩɢɫɢ,
ɬɚɤ ɢ ɞɥɹ ɱɬɟɧɢɹ. ɉɨɪɬ ɫɨɫɬɨɹɧɢɹ ɫɨɞɟɪɠɢɬ ɢɧɮɨɪɦɚɰɢɸ ɨ ɬɟɤɭɳɟɦ ɫɨɫɬɨɹɧɢɢ
ɩɨɞɤɥɸɱɟɧɧɨɝɨ ɭɫɬɪɨɣɫɬɜɚ ɢ ɞɨɫɬɭɩɟɧ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ (ɬɚɛɥ. 3.5). ɉɨɪɬ
ɭɩɪɚɜɥɟɧɢɹ ɩɨɡɜɨɥɹɟɬ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɭɫɬɪɨɣɫɬɜɨ (ɱɚɳɟ ɜɫɟɝɨ ɷɬɨ ɩɪɢɧɬɟɪ) ɢ
ɭɫɬɚɧɨɜɢɬɶ
ɪɚɡɥɢɱɧɵɟ ɩɚɪɚɦɟɬɪɵ ɪɚɛɨɬɵ (ɬɚɛɥ. 3.6).
96
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.5
Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɫɨɫɬɨɹɧɢɹ LPT
ʋ ɛɢɬɚ ɇɚɡɧɚɱɟɧɢɟ
0–2 ɇɟ ɢɫɩɨɥɶɡɭɸɬɫɹ (ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧɵ ɜ 0)
3 Ɉɲɢɛɤɚ ɜɜɨɞɚ-ɜɵɜɨɞɚ (1 – ɧɟɬ, 0 – ɟɫɬɶ)
4 ȼɵɛɨɪ ɭɫɬɪɨɣɫɬɜɚ (1 – ɞɨɫɬɭɩɧɨ, 0 – ɧɟɞɨɫɬɭɩɧɨ)
5 Ɂɚɤɨɧɱɢɥɚɫɶ ɛɭɦɚɝɚ (1 – ɧɟɬ ɛɭɦɚɝɢ, 0 – ɛɭɦɚɝɚ ɟɫɬɶ)
6
ɉɨɞɬɜɟɪɠɞɟɧɢɟ ɩɪɢɟɦɚ ɞɚɧɧɵɯ (0 – ɭɫɬɪɨɣɫɬɜɨ ɝɨɬɨɜɨ, 1 –
ɭɫɬɪɨɣɫɬɜɨ ɧɟ ɝɨɬɨɜɨ)
7 Ƚɨɬɨɜɧɨɫɬɶ ɭɫɬɪɨɣɫɬɜɚ (1 – ɭɫɬɪɨɣɫɬɜɨ ɫɜɨɛɨɞɧɨ, 0 – ɡɚɧɹɬɨ)
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.6
Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɭɩɪɚɜɥɟɧɢɹ LPT
ʋ ɛɢɬɚ ɇɚɡɧɚɱɟɧɢɟ
ɋɨɫɬɨɹɧɢɟ ɥɢɧɢɢ STROBE (1 – ɦɨɠɧɨ ɩɟɪɟɞɚɬɶ ɞɚɧɧɵɟ ɧɚ
0
ɭɫɬɪɨɣɫɬɜɨ, 0 – ɫɬɚɧɞɚɪɬɧɨɟ ɫɨɫɬɨɹɧɢɟ)
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɚɜɬɨɦɚɬɢɱɟɫɤɨɝɨ ɩɟɪɟɜɨɞɚ ɫɬɪɨɤɢ LF (Ah)
1
ɩɨɫɥɟ ɜɨɡɜɪɚɬɚ ɤɚɪɟɬɤɢ CR (Dh): 1 – ɢɫɩɨɥɶɡɨɜɚɬɶ
ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɩɨɪɬɚ ɭɫɬɪɨɣɫɬɜɚ (0 – ɜɵɩɨɥɧɢɬɶ ɧɚɱɚɥɶɧɭɸ
2
ɢɧɢɰɢɚɥɢɡɚɰɢɸ)
ȼɵɛɨɪ ɭɫɬɪɨɣɫɬɜɚ (1 – ɭɫɬɪɨɣɫɬɜɨ ɞɨɫɬɭɩɧɨ, 0 – ɭɫɬɪɨɣɫɬɜɨ
3
ɧɟɞɨɫɬɭɩɧɨ)
ɂɫɩɨɥɶɡɨɜɚɬɶ ɩɪɟɪɵɜɚɧɢɟ ɨɬ ɭɫɬɪɨɣɫɬɜɚ (1 – ɢɫɩɨɥɶɡɨɜɚɬɶ,
4
0 – ɧɟɬ)
5–7 ɇɟ ɢɫɩɨɥɶɡɭɸɬɫɹ (ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧɵ ɜ 0)
ɉɟɪɟɞ ɧɚɱɚɥɨɦ ɪɚɛɨɬɵ ɫ LPT-ɩɨɪɬɨɦ ɟɝɨ ɧɟɨɛɯɨɞɢɦɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ,
ɤɚɤ ɩɨɤɚɡɚɧɨ ɜ ɩɪɢɦɟɪɟ ɧɢɠɟ. ȿɫɥɢ ɩɪɨɢɡɨɲɥɚ ɨɲɢɛɤɚ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ, ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɫɥɟɞɭɟɬ ɩɨɜɬɨɪɢɬɶ.
ɉɪɢɦɟɪ 3.18. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɩɚɪɚɥɥɟɥɶɧɨɝɨ ɩɨɪɬɚ ɜ Ⱥɫɫɟɦɛɥɟɪɟ.
; ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɩɚɪɚɥɥɟɥɶɧɨɝɨ ɩɨɪɬɚ
MOV DX, 37Ah ; ɩɨɪɬ ɭɩɪɚɜɥɟɧɢɹ LPT1 ɢɥɢ LPT2
MOV AL, OCh ; ɩɨɞɝɨɬɚɜɥɢɜɚɟɦ ɩɨɪɬ
OUT DX, AL ; ɡɚɩɢɫɵɜɚɟɦ ɡɧɚɱɟɧɢɟ ɜ ɩɨɪɬ
; ɮɨɪɦɢɪɭɟɦ ɡɚɞɟɪɠɤɭ (ɧɟ ɦɟɧɟɟ 0,5 ɦɤɫ)
MOV ɋɏ, 1500 ; ɧɚɱɚɥɶɧɨɟ
ɡɧɚɱɟɧɢɟ ɫɱɟɬɱɢɤɚ delay:
LOOP delay ; ɩɨɜɬɨɪ CX ɪɚɡ
MOV AL, 08h ; ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɩɨɪɬɚ
OUT DX, AL ; ɡɚɩɢɫɵɜɚɟɦ ɡɧɚɱɟɧɢɟɜ ɩɨɪɬ ; ɭɩɪɚɜɥɟɧɢɹ
LPT-ɩɨɪɬɚ
97
ɉɪɢɦɟɪ 3.19. Ɏɭɧɤɰɢɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɩɚɪɚɥɥɟɥɶɧɨɝɨ ɩɨɪɬɚ ɜ ɋɢ (Win-
dows, ɩɨɞɤɥɸɱɢɬɟ conio.h ɢ unistd.h).
// Ɏɭɧɤɰɢɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ
void InitLPTW (unsigned short Port) {
__outbyte(Port, 0x0C); // ɩɨɞɝɨɬɚɜɥɢɜɚɟɦ ɩɨɪɬ
usleep(1); // ɡɚɞɟɪɠɤɚ 1 ɫɟɤɭɧɞɚ
__outbyte(Port, 0x08); // ɢɧɢɰɢɚɥɢɡɢɪɭɟɦ ɩɨɪɬ )
ɉɪɢɦɟɪ 3.20. Ɏɭɧɤɰɢɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɩɚɪɚɥɥɟɥɶɧɨɝɨ ɩɨɪɬɚ ɜ ɋɢ (Linux,
ɩɨɞɤɥɸɱɢɬɟ sys/io.h ɢ stdio.h).
int InitLPTL (unsigned int Port) {
// ɉɪɟɞɨɫɬɚɜɥɹɟɦ ɞɨɫɬɭɩ ɤ ɩɨɪɬɭ
if(ioperm(Port, 1, 1)) {
// ȿɫɥɢ ɜɨɡɧɢɤɥɚ ɨɲɢɛɤɚ
printf("Ⱦɨɫɬɭɩ ɡɚɩɪɟɳɟɧ, ɜɵɯɨɞɢɦ\
ɉ");
return (-1); // ȼɨɡɜɪɚɳɚɟɦ ɤɨɞ ɨɲɢɛɤɢ
}
outb(0x0C, Port); // ɩɨɞɝɨɬɚɜɥɢɜɚɟɦ ɩɨɪɬ
outb(0x08, Port); // ɢɧɢɰɢɚɥɢɡɢɪɭɟɦ ɩɨɪɬ
}
ȼ ɩɪɢɦɟɪɚɯ 3.19, 3.20 ɮɭɧɤɰɢɢ __outbyte (Windows) ɢ outb (Linux)
ɨɫɭɳɟɫɬɜɥɹɸɬ ɜɵɜɨɞ ɛɚɣɬɚ ɜ ɪɟɝɢɫɬɪ ɩɨɪɬɚ ɩɨ ɡɚɞɚɧɧɨɦɭ ɚɞɪɟɫɭ. Ɏɭɧɤɰɢɹ
ioperm (Linux) ɞɚɟɬ ɞɨɫɬɭɩ ɤ ɭɤɚɡɚɧɧɨɦɭ ɞɢɚɩɚɡɨɧɭ ɩɨɪɬɨɜ, ɧɚɱɢɧɚɹ ɫ Port.
ɉɨɫɥɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɫɥɟɞɭɟɬ ɩɪɨɜɟɪɢɬɶ ɝɨɬɨɜɧɨɫɬɶ ɭɫɬɪɨɣɫɬɜɚ, ɩɨɞɤɥɸɱɟɧɧɨɝɨ ɱɟɪɟɡ LPT.
ɉɪɢɦɟɪ 3.21. ɉɪɨɜɟɪɤɚ ɝɨɬɨɜɧɨɫɬɢ ɩɨɪɬɚ LPT ɜ
Ⱥɫɫɟɦɛɥɟɪɟ.
XOR AL, AL ; «ɨɛɧɭɥɹɟɦ» ɩɨɪɬ
MOV DX, 379h ; ɩɨɪɬ ɫɨɫɬɨɹɧɢɹ LPT1 ɢɥɢ LPT2
IN AL, DX ; ɱɢɬɚɟɦ ɛɚɣɬ ɢɡ ɩɨɪɬɚ
TEST AL, 10000b; ɩɪɨɜɟɪɹɟɦ 4-ɣ ɛɢɬ
JZ NO_ONLINE; ɭɫɬɪɨɣɫɬɜɨ ɧɟ ɩɨɞɤɥɸɱɟɧɨ
ɉɪɢɦɟɪ 3.22. Ɏɭɧɤɰɢɹ ɩɪɨɜɟɪɤɢ ɝɨɬɨɜɧɨɫɬɢ ɩɨɪɬɚ LPT ɜ ɋɢ (Windows).
bool TestLPTW (unsigned short Port)
{
unsigned char dwResult = 0;
// ɱɢɬɚɟɦ ɛɚɣɬ ɢɡ ɩɨɪɬɚ
__inbyte(Port, &dwResult);
if ( ( dwResult &0x10) == 0x01)
return true; // ɭɫɬɪɨɣɫɬɜɨ ɩɨɞɤɥɸɱɟɧɨ
return false; // ɭɫɬɪɨɣɫɬɜɨ ɧɟ ɩɨɞɤɥɸɱɟɧɨ
}
ɉɪɢɦɟɪ 3.23. Ɏɭɧɤɰɢɹ ɩɪɨɜɟɪɤɢ ɝɨɬɨɜɧɨɫɬɢ ɩɨɪɬɚ LPT ɜ ɋɢ (Linux).
bool TestLPTW (unsigned short Port)
{
int dwResult = 0;
// ɉɪɟɞɨɫɬɚɜɥɹɟɦ ɞɨɫɬɭɩ ɤ
98
ɩɨɪɬɭ
if(ioperm(Port, 1, 1)) {
// ȿɫɥɢ ɜɨɡɧɢɤɥɚ ɨɲɢɛɤɚ
printf("Ⱦɨɫɬɭɩ ɡɚɩɪɟɳɟɧ, ɜɵɯɨɞɢɦ\ɩ");
return(-1); // ȼɨɡɜɪɚɳɚɟɦ ɤɨɞ ɨɲɢɛɤɢ
}
// ɱɢɬɚɟɦ ɛɚɣɬ ɢɡ ɩɨɪɬɚ
dwResult = inbyte (Port);
if ( (dwResult &0x10) == 0x01)
return true; // ɭɫɬɪɨɣɫɬɜɨ ɩɨɞɤɥɸɱɟɧɨ
return false; // ɭɫɬɪɨɣɫɬɜɨ ɧɟ ɩɨɞɤɥɸɱɟɧɨ
}
ɉɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɩɨɪɬ ɨɬɤɪɵɬ ɢ ɩɪɨɜɟɞɟɧɚ ɩɪɨɜɟɪɤɚ ɝɨɬɨɜɧɨɫɬɢ ɭɫɬɪɨɣɫɬɜɚ,
ɦɨɠɧɨ ɩɪɨɢɡɜɨɞɢɬɶ ɨɩɟɪɚɰɢɢ ɜɜɨɞɚ-ɜɵɜɨɞɚ.
ɉɪɢɦɟɪ 3.24. Ɏɭɧɤɰɢɹ ɞɥɹ ɩɟɪɟɞɚɱɢ ɛɚɣɬɚ ɧɚ ɩɪɢɧɬɟɪ (Windows).
int WriteByteToLPT (unsigned short Port,
unsigned char Data)
{
unsigned char dwResult = 0;
int iTimeWait = 5000;
// ɩɪɨɜɟɪɹɟɦ ɝɨɬɨɜɧɨɫɬɶ
ɩɨɪɬɚ
while (-- iTimeWait > 0) {
// ɱɢɬɚɟɦ ɩɨɪɬ ɫɨɫɬɨɹɧɢɹ
dwResult = __inbyte(Port + 1);
if ( (dwResult &0x80 ) == 0x00 ) break;
// ɟɫɥɢ ɡɚɤɨɧɱɢɥɨɫɶ ɜɪɟɦɹ ɨɠɢɞɚɧɢɹ
if (iTimeWait < 1 ) return 1; }
// ɡɚɩɢɫɵɜɚɟɦ ɡɧɚɱɟɧɢɟ ɛɚɣɬɚ ɞɚɧɧɵɯ ɜ ɩɨɪɬ
__outbyte(Port, Data);
// ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɢɝɧɚɥ STROBE
__outbyte(Port + 2, 0x0D);
// ɫɛɪɚɫɵɜɚɟɦ ɫɢɝɧɚɥ STROBE
__outbyte(Port + 2, 0x0C);
// ɩɪɨɜɟɪɹɟɦ ɝɨɬɨɜɧɨɫɬɶ ɩɪɢɧɬɟɪɚ ɤ ɩɪɢɟɦɭ
// ɫɥɟɞɭɸɳɟɝɨ ɫɢɦɜɨɥɚ
iTimeWait = 10000;
while (-- iTimeWait > 0) {
// ɱɢɬɚɟɦ ɩɨɪɬ ɫɨɫɬɨɹɧɢɹ
dwResult = __inbyte(BasePort + 1);
if ((dwResult &0x08) == 0x00) return 2;
// ɩɪɨɢɡɨɲɥɚ ɨɲɢɛɤɚ
if ((dwResult &0x80) == 0x01) break;
// ɡɚɤɨɧɱɢɥɨɫɶ ɜɪɟɦɹ ɨɠɢɞɚɧɢɹ
if (iTimeWait < 1) return 1; }
return 0; // ɟɫɥɢ ɜɫɟ ɜ ɩɨɪɹɞɤɟ
}
99
Ⱦɨɫɬɭɩ ɤ LPT-ɩɨɪɬɭ ɜ Windows ɦɨɠɧɨ ɬɚɤɠɟ ɩɪɨɢɡɜɟɫɬɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
ɮɭɧɤɰɢɣ API [7].
ɉɪɢɦɟɪ 3.25. ɂɫɩɨɥɶɡɨɜɚɧɢɟ Windows API ɞɥɹ ɞɨɫɬɭɩɚ ɤ ɩɨɪɬɭ LPT.
#include <windows.h>
#include <stdio.h>
int main() {
HANDLE hLPT = CreateFile("LPT1",
GENERIC_WRITE,0,NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,NULL);
if (hLPT!=INVALID_HANDLE_VALUE) {
printf("LPT1 ɨɬɤɪɵɬ\ɩ");
char buffer[25];
memset(buffer,0,sizeof(buffer));
strcpy(buffer,"Tecmupoɜaɧue LPT ");
DWORD dw; OVERLAPPED ov; int i;
for (i = 0;i < 3;i++)
WriteFile(hLPT,buffer,sizeof(buffer),&dw,&ov);
CloseHandle(hLPT); }
else printf("ɉɪɨɢɡɨɲɥɚ ɨɲɢɛɤɚ \n");
return 0; }
Ʉɚɤ ɜɢɞɧɨ ɢɡ ɩɨɫɥɟɞɧɟɝɨ ɩɪɢɦɟɪɚ, ɞɨɫɬɭɩ ɤ LPT-ɩɨɪɬɭ ɱɟɪɟɡ API- ɮɭɧɤɰɢɢ
ɜ Windows ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɤɚɤ ɤ ɮɚɣɥɭ.
3.3.3. ɉɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬ
ɉɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬ (ɢɧɬɟɪɮɟɣɫ ɫɬɚɧɞɚɪɬɚ RS-232) ɩɪɨɢɡɜɨɞɢɬ ɩɟɪɟɞɚɱɭ ɞɚɧɧɵɯ ɩɨɛɢɬɧɨ ɜ ɞɜɭɯ ɧɚɩɪɚɜɥɟɧɢɹɯ ɫ ɡɚɞɚɧɧɨɣ ɱɚɫɬɨɬɨɣ. ɉɟɪɟɞɚɜɚɟɦɵɣ
ɛɥɨɤ ɞɚɧɧɵɯ ɜ ɚɫɢɧɯɪɨɧɧɨɦ ɪɟɠɢɦɟ ɫɨɫɬɨɢɬ ɢɡ 10 ɛɢɬ: ɫɬɚɪɬɨɜɨɝɨ ɛɢɬɚ, 8 ɛɢɬɨɜ
ɞɚɧɧɵɯ ɢ ɫɬɨɩ-ɛɢɬɚ.
ɋɤɨɪɨɫɬɶ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ ɱɟɪɟɡ COM-ɩɨɪɬ ɩɪɢɧɹɬɨ ɢɡɦɟɪɹɬɶ ɜ ɛɨɞɚɯ (ɛɢɬɵ ɜ ɫɟɤɭɧɞɭ). ɋɤɨɪɨɫɬɶ ɩɟɪɟɞɚɱɢ ɦɨɠɟɬ ɢɦɟɬɶ ɫɥɟɞɭɸɳɢɟ ɡɧɚɱɟɧɢɹ: 180, 300,
1 200, 2400, 4800, 9600, 19200, 38400, 57600
ɢ 115200 ɛɨɞ. ȿɫɥɢ ɞɜɚ ɭɫɬɪɨɣɫɬɜɚ
(ɧɚɡɵɜɚɟɦɵɯ ɱɚɫɬɨ ɦɨɞɟɦɚɦɢ) ɢɦɟɸɬ ɪɚɡɥɢɱɧɵɟ ɫɤɨɪɨɫɬɢ ɩɟɪɟɞɚɱɢ, ɬɨ ɞɥɹ ɢɯ
ɫɢɧɯɪɨɧɢɡɚɰɢɢ ɢ ɫɧɢɠɟɧɢɹ ɤɨɥɢɱɟɫɬɜɚ ɨɲɢɛɨɤ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɧɚ ɧɚɢɦɟɧɶɲɚɹ ɢɡ ɡɚɞɚɧɧɵɯ ɫɤɨɪɨɫɬɟɣ. ɋɬɚɪɬɨɜɵɣ ɛɢɬ ɢ ɫɬɨɩ-ɛɢɬ ɨɩɪɟɞɟɥɹɸɬ ɧɚɱɚɥɨ ɢ
ɨɤɨɧɱɚɧɢɟ ɛɥɨɤɚ ɞɚɧɧɵɯ, ɚ ɞɥɹ ɫɧɢɠɟɧɢɹ ɤɨɥɢɱɟɫɬɜɚ ɨɲɢɛɨɤ ɩɟɪɟɞɚɱɢ ɩɟɪɟɞɚɟɬɫɹ ɬɚɤɠɟ ɫɩɟɰɢɚɥɶɧɵɣ ɛɢɬ ɱɟɬɧɨɫɬɢ.
Ɋɚɫɩɪɟɞɟɥɟɧɢɟ ɚɞɪɟɫɨɜ ɞɥɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɩɨɪɬɨɜ ɤɨɦɩɶɸɬɟɪɚ ɩɨɤɚɡɚɧɨ ɜ ɬɚɛɥɢɰɟ 3.7.
100
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]