comgt - מקוון בענן

תָכְנִית:

שֵׁם

comgt - אפשרות GlobeTrotter בקרת כרטיס נתונים GPRS/EDGE/3G/HSDPA ו-Vodafone 3G/GPRS
כלי

תַקצִיר

comgt -d מכשיר -ehstvVx תסריט

אפשרויות

-d מכשיר
הגדר את המכשיר לשימוש לתקשורת עם כרטיס הנתונים. אם לא
צוין ואז comgt trys /dev/noz2, /dev/ttyUSB2 ולאחר מכן /dev/modem

-e
הפעל הד תקשורת טורית.

-h
הצג עזרה בסיכום וצא.

-s
אל תפעיל את הפנימי ברירת מחדל סקריפט לפני סקריפט חיצוני.

-t
שנה למסיים קו חלופי (ברירת מחדל "0).

-v
לרוץ במצב מילולי. זה עוקב אחר סקריפטים בזמן שהם מבוצעים. זה
נועד לעזור באיתור באגים של סקריפטים.

-V
מידע על גרסת הדפסה.

-x
עבור סקריפטים פנימיים וחיצוניים, כל התייחסות ל-115200 baud היא
הומר ל-57600. זה שימושי עבור כרטיסי נתונים שלא אוהבים את 115200
baud כגון GlobeTrotter EDGE.

תיאור

comgt הוא מתורגמן לשפת סקריפטים שימושי ליצירת תקשורת סדרתית
קווים ודרך מודמי PCMCIA וכן כרטיסי GPRS ו-3G.

comgt יש כמה תכונות שנמצאות רק לעתים רחוקות בכלי שירות אחרים מאותו סוג.

תכונות
- סקריפטים מובנים מוגדרים מראש לשליטה בכרטיסי נתונים 2G/3G
- שפת סקריפט פשוטה, דמוית BASIC.
- שורת פקודה ומקור קבצים של סקריפט.
- המתנה מרובת תגובות.
- שקט המתנה מאפשר ייצוב קו.
- לכידת טקסט בשורה.
- תמיכה בריבוי תהליכים: מזלג, המתן, הרוג, יציאה.
- איתור באגים מילולי ופלט יומן.
- כניסה לקובץ.
- בקרת זרימה: goto, gosub, return, if, else.
- השפעה נמוכה על משאבי המערכת.
- פקודות זמן ופונקציות.
- מניפולציות על מיתרים.
- מניפולציה של הסביבה: env(), putenv.
- קריאות מערכת עזר חיצוניות: system, exec.

נתמך GPRS ו 3G כרטיסי נתונים
comgt נבדק נגד GlobeTrotter GPRS, EDGE, Combo EDGE, 3G, 3G EDGE, HSDPA ו
GlobeTrotter Fusion כמו גם Vodafone 3G. זה יכול להגדיר את ה-PIN ולהציג מידע
על כרטיסי נתונים לפני תחילת חיבור PPP. בנוסף, בגלל ה
לכרטיס הנתונים של GlobeTrotter ו-Vodafone 3G/GPRS יש ממשק טורי משני, אלה
ניתן לנטר כרטיסי נתונים בזמן שקיים חיבור PPP ומעביר נתונים.

comgt תוכנן בעיקר לעבוד עם מגוון כרטיסי הנתונים של GlobeTrotter, אבל צריך להיות
תואם לכל כרטיס נתונים GPRS או 3G אחר בתנאי שהממשק שלו מיושם כאחד
או יותר התקנים טוריים או USB טוריים והוא נשלט ושאילתה על ידי יישום
של ממשק הפקודות של Hayes עם אותן הרחבות פקודת AT המשמשות את הרשומים
כרטיסי נתונים.

שימוש comgt
comgt יש רק פונקציה אחת: להפעיל סקריפט. זה עשוי להיות אחד ממספר "סטנדרטיים"
תסריטים פנימיים או תסריט חיצוני. שני סוגי הסקריפט מופעלים באותו אופן.
התסריטים ה"סטנדרטיים" מובנים comgt ויעבוד עבור מודמים מחוברים סדרתית,
מודמים מובנים, מודמי PCMCIA וכן GlobeTrotter GPRS ו-Vodafone 3G/GPRS
כרטיסי נתונים. יש סדר עדיפות לחיפוש עבור סקריפטים - 1) פנימי, 2) עבודה
מדריך, 3)/etc/comgt

Built-in סקריפטים
comgt
זה מפעיל את הסקריפט הפנימי המוגדר כברירת מחדל. רץ comgt ללא כל סקריפט שצוין, למשל,
comgt -d /dev/ttyS1 הוא יבדוק אם יש PIN וינחה אותך אם הוא נדרש. הבא
הדבר שהוא עושה הוא לחכות שהמכשיר יירשם, ואז הוא ידווח על עוצמת האות. אם
אתה לא מציין יציאה עם ה -d אפשרות אז /dev/modem מונחה. אם מתג -s
אינו בשימוש, אז סקריפט ברירת המחדל הזה מופעל לפני כל סקריפט חיצוני.

comgt לעזור
מפרט את האפשרויות הללו ואת שאר האפשרויות הזמינות.

comgt מידע
מפרט את תצורת כרטיס הנתונים.

comgt sig
מדפיס את עוצמת האות.

comgt רג
מדפיס את מצב הרישום.

comgt 3G
מכניס את GlobeTrotter 3G/Fusion ו-Vodafone 3G למצב רשת 3G בלבד (UMTS/HSDPA).

comgt 2G
מכניס GlobeTrotter 3G/Fusion ו-Vodafone 3G למצב רשת 2G בלבד (GSM/GPRS/EDGE).

comgt 3G2G
מכניס את GlobeTrotter 3G/Fusion ו-Vodafone 3G למצב מועדף 3G (UMTS/HSDPA ו
GSM/GPRS/EDGE).

comgt GTEDGE
השתמש בפקודה זו כדי לאתחל כרטיסי GlobeTrotter EDGE ו- GlobeTrotter Combo EDGE לפני
עושה כל דבר אחר. (זה מדליק את הרדיו).

comgt ארה"ב
עבור לפס 900/1900 מגה-הרץ לפעולה בארה"ב. כרטיסי נתונים של GlobeTrotter GPRS בלבד.

comgt אירופה
עבור לפס 900/1800 מגה-הרץ לפעולה אירופית. כרטיסי נתונים של GlobeTrotter GPRS בלבד.

comgt קוד אישי
בדוק את מצב ה-PIN של ה-SIM והשתמש במשתנה הסביבה COMGTPIN כערך.

comgt APN
הגדר את ה-APN של כרטיס הנתונים לערך הכלול במשתנה הסביבה COMGTAPN.

מותאם אישית סקריפטים
כמו גם סקריפטים מובנים אתה יכול ליצור בעצמך. הסקריפט הבא מגדיר Vodafone 3G
מצב UMTS של כרטיס נתונים או Option Fusion ל-GPRS:

#הגדר מצב GPRS בלבד
set com 115200n81
הגדר עיכוב שליחה 0.05
מחכה שקט 1 0.2
שלח "AT_OPSYS=0^m"
הדפס "הגדרת מצב GPRS בלבד"

אם שמרת את הסקריפט לעיל בתור GPRS, היית קורא לזה כך:

comgt GPRS

אם היית צריך לציין גם את היציאה אז עשה זאת:

comgt -d /dev/ttyS1 GPRS

אתה יכול גם להעביר פרמטרים של סביבה ל-a comgt תסריט באמצעות $env().

החלפתי צ'אט
צ'אט הוא כלי עזר שמגיע עם חבילת ppp (עבור לינוקס, בכל מקרה), עם סט של
מצפה-שלח זוגות מחרוזת, עושה מספיק כדי לחבר את רוב האנשים לספקי אינטרנט וכדומה. בזמן
השימוש בצ'אט הוא פשוט מאוד, הוא לא מאוד גמיש. זה המקום comgt משתלט.

comgt ניתן להשתמש במקום צ'אט תוך שימוש באותה אסטרטגיה. לדוגמה, שורת pppd
קריאה:

pppd להתחבר \
´chat -v "" ATDT5551212 CONNECT "" כניסה: ppp \
מילה: מים לבן' \
/dev/cua1 38400 debug crtscts modem default route

היה, באמצעות קומגט, לקרוא:

pppd connect ´comgt -s /root/scripts/isp.scr´ /dev/cua1 38400 \
איתור באגים של crtscts מסלול ברירת מחדל של מודם

והתסריט isp.scr היה קורא:

שלח "ATDT5551212^m"
חכה ל-60 "כניסה:"
שלח "ppp^m"
חכה ל-60 "מילה:"
שלח "whitewater^m"

כמובן שזה הופך להיות טריוויאלי להפוך את התסריט הזה להרבה יותר פונקציונלי על ידי
הוספת קוד לזיהוי תפוס, חיוג חוזר וכו'...

מילולית תפוקה
כאשר האפשרות המילולית מופעלת, comgt מדווח הכל על השגיאה הסטנדרטית
עָרוּץ. אם מופעל משורת הפקודה (-v), הפלט מכיל 4 מקטעים.

- פעולות ארגומנט שורת הפקודה
אלו הן פעולות שנעשו בגלל שהן צוינו משורת הפקודה, כגון
פתיחת התקן תקשורת (-d) וכו'... כדי שאלו יהיו פלט, עליך לציין -v
כטענה הראשונה.

- רשימת טיעונים
המספר ורשימת הטיעונים עברו. זה שימושי למקרה שיש לך חבורה של
משתני סביבה או מרכאות, מרכאות אחורה, קווים אחוריים בשורת הפקודה ואתם
לא בטוח מה התסריט באמת רואה.

- רשימת תסריטים
רשימה של הסקריפט לביצוע. זה עשוי להיות שרשור של ברירת המחדל הפנימית
סקריפט, אלא אם זה נדחק על ידי האפשרות -s וקובץ סקריפט. כל שורה היא
רשום עם מספר השורה ומיקום התו.

- פלט ביצוע
רשימת הפקודות תוך כדי ביצוען. המנתח מדפיס את הקו המופעל כעת,
החל מהנקודה המדויקת שבה היא נמצאת עד סוף הקו. פקודה מרובה
קבוצות בקו יחיד מייצרות קווי פלט מרובים. ניתן לערבב פלט מילולי עם
פלט סקריפט (הדפס, eprint או lprint.)

הנה דוגמה:

$ comgt -v -d/dev/cua1 -s blah.scr
comgt 00:18:46 -> פלט מפורט מופעל
comgt 00:18:46 -> קובץ סקריפט: blah.scr
comgt 00:18:46 -> argc:5
comgt 00:18:46 -> argv[0]=comgt
comgt 00:18:46 -> argv[1]=-v
comgt 00:18:46 -> argv[2]=-d/dev/cua1
comgt 00:18:46 -> argv[3]=-s
comgt 00:18:46 -> argv[4]=blah.scr
comgt 00:18:46 -> ---תסריט---
1@0000 set com 38400n81 let a=2
2@0025 הדפס "9x",a,"=",9*a,"\n"
3@0051 שינה 5
4@0059 יציאה 0
comgt 00:18:46 -> ---סוף סקריפט---
comgt 00:18:46 -> @0000 set com 38400n81 let a=2
comgt 00:18:46 -> @0017 let a=2
comgt 00:18:46 -> @0025 הדפס "9x",a,"=",9*a,"\n"
9x2 = 18
comgt 00:18:46 -> @0051 שינה 5
comgt 00:18:51 -> @0059 יציאה 0

תכנות מדריך ל

תחביר
התחביר המשמש עבור comgt סקריפטים די פשוטים, קצת כמו BASIC. תסריט הוא א
קובץ טקסט ASCII טהור ללא סמל המכיל שורות המסתיימות על ידי תווי שורה חדשה
(סטנדרט יוניקס.) ניתן ליצור ו/או לשנות סקריפטים באמצעות כל עורך טקסט רגיל
(vi, vim, joe, pico, emacs, ed, microEmacs) שורות ב- comgt התסריט נקרא כך:

- קו ריק
- הערה [indent] rem
- [indent][[:|label] LABEL] [פקודה [טיעונים]] הערה rem
- [indent][[:|label] LABEL] [פקודה [טיעונים]] [פקודה [טיעונים]]...

התווים המשמשים להזחה הם תווי הרווח והטבלה.
הפקודה rem גורמת למנתח הסקריפט לדלג על שאר השורה.
ניתן לכתוב את הפקודה rem גם כ-"#" או "//".

תוויות מורכבות מאותיות קטנות ורישיות וספרות.
התוויות מתעלמות מהתיק.

פקודות והארגומנטים שלהן מופרדים על ידי רווחים ו/או טאבים.
קבוצות פקודות מופרדות על ידי רווחים, טאבים או שורות חדשות.

אסור לביטויים להכיל רווחים או טאבים.
זה בסדר: תן n=x+76
זה לא: תן n= x + 76
מכיוון שהרווח הזה ^ יסיים את קבוצת הפקודות let.

שְׁגִיאָה דיווח
מתי comgt מזהה שגיאת סקריפט, הוא מיד מופעל במצב מילולי, יוצר dump
(ראה את הפקודה dump), מדווח על השגיאה בשלוש שורות ומפסיק את הביצוע. ה
השורה הראשונה שדווחה היא קבוצת הפקודות שמתבצעת, השנייה מראה היכן
parser got והשורה השלישית מדווחת על מיקום התווים של מונה התוכנית, ה
שגיאה וקוד היציאה.

הנה דוגמה:

$ comgt -vs blar2.scr

היכן נמצא הסקריפט blar2.scr:

inc n
דצמבר ד3
תן a=58/3
תן $d="fod"
תן c=1/0
תן $y4="sdfgsdfgsdfg"

דוח המעקב והשגיאה נראה כך:

comgt 11:20:15 -> פלט מפורט מופעל
comgt 11:20:15 -> קובץ סקריפט: blar2.scr
comgt 11:20:15 -> argc:3
comgt 11:20:15 -> argv[0]=comgt
comgt 11:20:15 -> argv[1]=-מול
comgt 11:20:15 -> argv[2]=blar2.scr
comgt 11:20:15 -> ---תסריט---
1@0000 inc n
2@0007 דצמבר ד3
3@0015 let a=58/3
4@0027 תן $d="fod"
5@0041 תן c=1/0
6@0052 תן $y4="sdfgsdfgsdfg"
comgt 11:20:15 -> ---סוף סקריפט---
comgt 11:20:15 -> @0000 inc n
comgt 11:20:15 -> @0007 dec d3
comgt 11:20:15 -> @0015 let a=58/3
comgt 11:20:15 -> @0027 let $d="fod"
comgt 11:20:15 -> @0041 let c=1/0
comgt 11:20:15 -> -- דוח שגיאות --
comgt 11:20:15 -> ----> ^
comgt 11:20:15 -> שגיאה @49, שורה 5, חלוקה באפס. (6)

יציאה קודים
מתי comgt מסתיים, הוא עושה זאת עם "קוד יציאה". זה מספר שהוחזר אליו
תהליך הקריאה לסמן הצלחה או כישלונות. ביוניקס היומיומי, 0 (אפס) פירושו
הצלחה וכל השאר פירושם כל מה שמחבר התוכנית רוצה שזה יתכוון. ב
סקריפט מעטפת, או ישירות בשורת הפקודה, תוכל להסתכל על התוכן של $? לאחר
לאחר שהתקשר comgt כדי לבחון את קוד היציאה שלו.

דוגמא:

#!/ Bin / sh
comgt /root/bin/call-isp
אם [$? != 0]; לאחר מכן
echo "אופס! משהו השתבש."
fi

פנימי comgt קודי השגיאה הם כדלקמן:

0: אין בעיות בכלל. ככל הנראה.
1: בעיות בהתקן תקשורת.
2 : בעיות בהתקן קונסולה (tty).
3: בעיות זיכרון.
4: בעיות בקובץ או בצינור.
5: שגיאות תחביר.
6: חלוקה באפס.
7: ניהול שגוי משתנה.
8: בעיות במערכת. (לא יכולתי להתקשר / Bin / sh או משהו כזה)

פקודות
פקודה: : כינוי: תווית
תיאור : מציין נקודת עיגון עבור goto או gosub להסתעפות אליה.
תחביר : מילת המפתח אינה יכולה להכיל תווים מיוחדים.
הערה: חייב להיות ההצהרה הראשונה בשורה.
ראה גם: goto, gosub, return.
דוגמא:
: לולאה
גוסוב בראבו
הדפס "השעה היא ",$time(),"\n"
לישון 1
לוטו
תווית בראבו
הדפס "Twonk!\n"
לַחֲזוֹר

פקודה: בטל
תיאור : גורם ל-comgt לקרוא ל- abort() וליצור dump core.
תחביר: בטל
ראה גם: dump, יציאה.

פקודה: CD
תיאור: שנה ספרייה.
תחביר: ספריית CD
הערות: -1 מוחזר ב-% אם לא ניתן היה לבצע את השינוי.
הערות: ספרייה היא מחרוזת ולכן יכולה להיות משתנה.
ראה גם: $cwd().
דוגמא:
תקליטור "אה"
אם % != 0 הדפס "לא ניתן היה לתקליטור לתוך duh.\n"

פקודה: סגור
תיאור: סוגר קובץ שנפתח בעבר עם פתיחה.
תחביר: סגור קובץ
ראה גם: פתוח.

פקודה: דצמבר
תיאור: מקטין את התוכן של משתנה מספר שלם ב-1.
תחביר: dec x
הערות: x הוא מ-a עד z או a0 עד z9.
הערות: שימו לב שגם "תן x=x-1" עובד.
ראה גם: let, inc.

פקודה: dump
תיאור : מפרט את כל משתני המספרים השלמים שאינם אפס והמחרוזת ששונתה
תיאור: משתנים כרשומות יומן (ערוץ שגיאה סטנדרטי.)
תחביר: dump
ראה גם: בטל, יציאה

פקודה: אחר
תיאור : לחלופין בצע פקודות אם ה-"אם" האחרון נבדק שקר.
תחביר: פקודות אחר...
ראה גם: אם
דוגמא:
if w<350 הדפס "וואו! תאר לעצמך את זה.\n"
else print "Rush Limbaugh הוא ממזר שמן וגדול.\n"

פקודה: eprint
תיאור: הדפס רשימה מופרדת בפסיקים של ארגומנטים ב-stderr.
תחביר: eprint var,stringvar,"text",...
הערות: כמו הדפסה אבל על מתאר קובץ השגיאה הסטנדרטי.
הערות: ניתן לנתב מחדש את פלט השגיאה כאשר "2>קובץ" פועל
הערות: שורת הפקודה.
ראה גם: הדפסה.

פקודה: exec
תיאור: מחליף תהליך comgt הנוכחי בתהליך אחר.
תחביר: exec "command -args..."
ראה גם: מערכת, מזלג.
דוגמא:
#תסריט גמור, התקשר ל-cu.
exec "cu -l "+$dev()+" -s "+$baud()

פקודה: יציאה
תיאור: מפסיק את ביצוע הסקריפט עם קוד יציאה.
תחביר: exit exit_code
ראה גם: בטל, dump.
דוגמא:
שגיאה
צא מ- 1
:smeggit
צא מ- 0

פקודה: הבזק
תיאור : מחליף DTR בהתקן תקשורת למשך זמן מוגדר.
תחביר: flash float_constant
הערות: float_constant מדויק עד 1/100 שניה.
הערות: גורם למודם להפיל את הספק או לעבור למצב פקודה,
הערות: תלוי בהגדרות המודם. הגדרת קצב ההחזרה ל-0
הערות: לזמן מה יש את אותה השפעה.
ראה גם: שינה, הגדר com.
דוגמא:
:לְנַתֵק
פלאש 0.5
צא מ- 0

פקודה: fprint
תיאור: הדפס רשימה מופרדת בפסיקים של ארגומנטים בקובץ.
תחביר: fprint var,stringvar,"text",...
הערות: כמו הדפסה אך צורפה לקובץ שנפתח קודם לכן
הערות: על ידי פתוח.
ראה גם: הדפסה.

פקודה: מזלג
תיאור : תהליך שילוב של מזלגות בשניים. שני התהליכים ממשיכים
תיאור: ביצוע הסקריפט.
תחביר: מזלג
הערות: % מחזיר 0 עבור תהליך צאצא, מזהה תהליך חדש עבור
הערות: אב או -1 לשגיאה.
ראה גם: wait, kill, pid(), ppid().
דוגמא:
מזלג
אם % = -1 יש לך שגיאה
אם % = 0 יש לך ילד
:הוֹרֶה
...

פקודה: קבל
תיאור: קבל מחרוזת מהתקן תקשורת.
תחביר : קבל פסק זמן של "terminators" $string
הערות: הזמן הקצוב הוא קבוע צף, terminators הוא a
הערות : רשימה של תווים שכאשר מתקבלים, מסתיימים
הערות: קבל. מתעלמים מהטרמינטורים כשהם מתקבלים לראשונה.
ראה גם: חכה ל.
דוגמא:
חכה ל-60 "התחבר"
אם % != 0 יש לך שגיאה
קבל 2 " ^m" $s
הדפס "פרמטרי חיבור: ",$s,"\n"

פקודה: gosub
תיאור: קורא לשגרת משנה.
תחביר: תווית gosub
הערות: נכון לעכשיו, comgt תומך רק ב-128 רמות של gosub
הערות: שיחות (מספיק!)
ראה גם : :, goto, return.
דוגמא:
שגרת gosub
לישון 1
שגרת gosub
סוף לנאמני תורה
:שגרה
הדפס "Flim-flam!\n"
לַחֲזוֹר

פקודה: goto
תיאור: שולח ביצוע למקום אחר בסקריפט.
תחביר: תווית goto
ראה גם : :, gosub, return.
דוגמא:
:win95
הדפס "היום אני רוצה ללכת להשתמש בלינוקס, תודה.\n"
צריך win95

פקודה: hset
תיאור: הגדר את טיימר מאות.
תחביר: ערך hset
הערות: פקודה זו מאפסת את הטיימר של מאות שניות ל
הערות: ערך עבור htime להתחיל ממנו.
ראה גם: htime().
דוגמא:
הסט 0
: לולאה
הדפס "זמן ב-1/100 של שניה: ",htime(),"\n"
לישון 0.01
לוטו

פקודה: אם
תיאור: בודק מצב
תחביר: אם פקודות test_condition...
הערות: מבצע באופן מותנה פקודות אם תנאי הבדיקה נכון.
הערות: אופרטורי הבדיקה הם = (שווה), != (לא שווים),
הערות: <> (לא שווה ל) (גדול מ),
הערות: = (גדול או שווה).
הערות: ניתן להשתמש בכל האופרטורים עם מספרים שלמים ומחרוזות.
הערות: אם test_condition הוא שקר, אם מדלג אל
הערות: השורה הבאה.
ראה גם: אחר.
דוגמא:
אם n>30 הדפס "או-הו! יותר מדי כבשים!\n" קבל שגיאה
אם n=17 הדפס "מהר! יש לנו מספיק כבשים\n" צא למסיבה
אם n<17 הדפס "Murray, get more sheep.\n" צריך לקבל עוד
אם $z < "Marmaluke" צריך...
אם 3*a>5+b צריך...

פקודה: Inc
תיאור: מגדיל את התוכן של משתנה מספר שלם ב-1.
תחביר: inc x
הערות: x הוא a-z או a0-z9.
ראה גם: דצמבר, תן.

פקודה: קלט
תיאור: קלט מחרוזת מהמקלדת למשתנה מחרוזת.
תחביר: קלט $x
הערות: קלט מסיים כניסה רק עם מקש ENTER.
הערות: רווחים, טאבים ודמויות מצחיקות אחרות הם כולם
הערות: מאוחסן במשתנה.
ראה גם: הגדר הד.
דוגמא:
הדפס "הזן את שמך המלא:"
קלט $n4

פקודה: להרוג
תיאור: שולח אות לתהליך.
תחביר: תהליך מזהה אות חיסול
הערות: גם האות וגם ה-procesID הם ערכים שלמים. כמו
הערות: הרג יוניקס רגיל, אלא שכינויי אותות לא
הערות: מקובל והאות אינו אופציונלי.
הערות: 0 מוחזר ב-% אם ניתן לשלוח את האות, -1
הערות: אחרת.
הערות: ניתן להשתמש באות 0 לזיהוי קיום תהליך.
ראה גם: wait, pid(), ppid().
דוגמא:
מזלג
תן p=%
אם p = 0 יש לך ילד
לישון 300
להרוג 15 עמ'
לישון 1
להרוג 0 עמ'
אם % != 0 הדפס "ילד הופסק\n" יעבור בסדר
הדפס "לא ניתן לסיים את הילד!\n"
להרוג 9 עמ'
לישון 1
להרוג 0 עמ'
אם % = 0 הדפס "לא יכול היה להרוג ילד!\n" עבור לשגיאה
הדפס "ילד נהרג.\n"
:בסדר
...

פקודה: תן
תיאור: מבצע הקצאת משתנה.
תחביר : תן x=תוכן
הערות: x הוא [$]a0-z9.
ראה גם: Inc., Dec.
דוגמא:
תן a=5
תן b=(זמן()-a)+5
תן y7=6809
תן z=0%11010111 #בינארי
let z=077324 #octal
תן z=0xf5b8 #הקסדצימלי
תן $c="דניאל"
תן $d=$c+" Chouinard"
let $s5="Frimpin´ Jeosaphat!"

פקודה: lprint
תיאור : הדפס רשימה מופרדת בפסיקים של ארגומנטים ביומן.
תחביר: fprint var,stringvar,"text",...
הערות: כמו הדפסה אבל מודפס כמו ערך יומן אם מילולית פועלת.
הערות: רישום רישום נשלח אל stderr.
ראה גם: הדפסה, הדפסה, הדפסה.

פקודה: פתח
תיאור : פותח קובץ או התקן תקשורת.
תחביר: פתח מכשיר com, פתח com (stdin), פתח קובץ FILE
ראה גם: סגור.
דוגמא:
פתח את com /dev/cua1
set com 38400n81
פתח את הקובץ "/tmp/log"
fprintf "זהו יומן\n"
לסגור קובץ

פקודה: הדפס
תיאור: הדפס רשימה של ארגומנטים מופרדים בפסיקים.
תחביר: print var,stringvar,"text",...
הערות: רווחים ושורות חדשות לא מתווספים אוטומטית.
ראה גם: eprint, fprint, lprint.
דוגמא:
תן b=26
תן $c="משתני טקסט"
הדפס "טקסט קבוע ",b," ",$c," זמן: ",$time(),"\n"

פקודה: putenv
תיאור: מגדיר משתנה סביבה.
תחביר: putenv "var=content"
הערות: משתני סביבה מיוצאים אוטומטית,
הערות: מעולם לא הוחזר. תהליכי ילדים יורשים את
הערות: סביבה.
ראה גם: $env().
דוגמא:
putenv "SCRIPTDIR=/usr/lib/comgt/scripts"
מערכת "dothat" # dothat קורא env. var. SCRIPTDIR...

פקודה : rem כינויים: #, //
תיאור: הערה. מתעלמים משאר הקו.
תחביר : שימו לב שרווח חייב אחרי "rem".
דוגמא:
#זו הערה
// כך גם זה
rem זה לא דיסקו.

פקודה: חזרה
תיאור : חוזר מתת שגרה.
תחביר: החזרה
ראה גם: gosub.

פקודה: שלח
תיאור : שולח מחרוזת לקו התקשורת (מודם בדרך כלל).
תחביר: שלח מחרוזת
הערות: החזרת עגלה (ENTER) לא נשלחת אוטומטית
הערות: (השתמש ב-^m).
דוגמא:
שלח "atdt555-1212^m"
שלח $g+"^m"
שלח "השעה היא "+$time()+"^m^j"

פקודה: הגדר
תיאור: קובע פרמטרי עבודה.
תחביר: הגדר ערך פרמטר
הערות:

תיאור הפקודה
------------------------------------------------------ ----------------------------
הגדר הד מופעל|כבוי הד מקלדת על המסך.
הפעל comecho on|off דמויות שהתקבלו הדהדו על המסך.
set delay time_constant send delay time_constant In-between character delay עבור "שלח"
הגדר ignorecase on|off רגישות רישיות עבור "waitfor".
ברירת מחדל = פועל.
הגדר את clocal on|off clocal on = התעלם מאותות מודם
הגדר את ברירת המחדל של מצב umask ליצירת מצב קובץ.
ראה גבר umask.
set verbose on|off verbose on = פלט ניפוי באגים מופעל.
הגדר פרמטרי תקשורת של com com_params.
לדוגמה: 19200n81, 300e71
baud |||
זוגיות |
סיביות נתונים |
עצור ביטים |

דוגמא:
לכבות הד
הדפס "סיסמה:"
קלט $p
הדפס "\n"
הפעל הד
הפעל את ה-comcho
להפעיל את clocal
הגדר עיכוב שליחה 0.1
הפעל את ignorecase
set com 38400n81
set umask 022 # חייב להיות אוקטלי (אפס מוביל)
...

הערה על קלוקל:
אם תרצה שהסקריפט שלך ימשיך לעבוד לאחר זיהוי הספק
האות ירד, הפעל את השעון, אחרת, נפילת תקליטור גורמת
את קו המכשיר לסגור (ניתוק). זה יכול לקרות אם,
נניח, הסקריפט שלך מתקשר ומתחבר, ואז מתנתק או
מפיל dtr (פלאש), ואז מנסה להתחבר שוב.

פקודה: לישון
תיאור: משהה את הביצוע.
תחביר: sleep float_constant
הערות: Float_constant מדויק עד 1/100 שניה, אלא אם כן
הערות: יותר מ-100 שניות, ובמקרה זה הדיוק
הערות: נופל לשנייה אחת.

דוגמא:
לישון 0.06
לישון 3
שינה 86400 /* יום שלם */

פקודה: מערכת
תיאור: קורא לפקודת מערכת (יוניקס).
תחביר: מערכת "פקודה"
ראה גם: exec.
דוגמא:
:dir
הדפס "רישום של ספרייה", $cwd(),\n"
מערכת "ls -l |more"

פקודה: מקש test
תיאור: בודק את המקלדת עבור הקשה, מחזיר 1 ב-% אם קיים.
תחביר: מפתח בדיקה
הערות: ניתן לבדוק רק עבור מקש ENTER. גרסאות עתידיות של comgt
הערות: יבדוק עוד ויחזיר קודי מפתח באחוזים.
ראה גם: קלט.
דוגמא:
תן n=1
: לולאה
print n," sheep... ZZZzzz...\n"
לישון נ
inc n
מפתח בדיקה
אם % = 0 goto לולאה

פקודה: המתן
תיאור : המתן עד שתהליך צאצא יסתיים.
תחביר: המתן
הערות: מזהה התהליך של הילד שהופסק מוחזר ב-%
ראה גם: מזלג, להרוג.
דוגמא:
מזלג
תן p=%
אם p=0 יש לך ילד
אם p=-1 קבל שגיאה
הדפס "מחכה שהילד יסיים..."
לחכות
הדפס "\n"
אם %!=p הדפס "המתנה שגיאה PID!\n" עבור לשגיאה
הדפס "הילד גמור.\n"

פקודה: לחכות
תיאור: ממתין עד שמתקבלת אחת מתוך רשימה של מחרוזות
תחביר: המתנה לזמן קצוב "string1", "string2", "string3"...
הערות: הזמן הקצוב הוא קבוע זמן צף. המתנה שקטה חוזרת
הערות: 0 עבור המחרוזת הראשונה שהתקבלה, 1 עבור השנייה וכו'...
הערות: ו-1 לזמן קצוב. כברירת מחדל, מתעלמים מהתיק, אלא אם כן
הערות: התעלמות במקרה של כבוי.
ראה גם: קבל.
דוגמא:
:חוּגָה
שלח "atdt555-4411^m"
המתן ל-60 "ללא ספק","עסוק","ללא צליל חיוג","התחבר"
אם % = -1 יש לעבור פסק זמן
אם % = 0 יש לך nocd
אם % = 1 צריך לחיוג חוזר
אם % = 2 יש לך שגיאה
אם % = 3 יש להתחבר

פקודה: המתן שקט
תיאור : ממתין עד שקו התקשורת יפסיק לקבל למשך זמן מה.
תחביר: זמן קצוב פסק זמן שקט להמתנה
הערות: גם פסק זמן וגם זמן שקט הם קבועי זמן צפים
הערות: עם 1/100 שניה. דיוק. שימושי ל"בליעה"
הערות: תווים נכנסים לזמן מה או ממתינים ל-
הערות: הנחיה לא ידועה.
דוגמא:
:closecon
שלח "logoff^m"
מחכה שקט 10 0.5
שלח "כן^מ"

מספר שלם פונקציות
I-Function: גישה
תיאור: מאמת זכויות גישה לקובץ
תחביר : let x=access("/tmp/file","frwx")
הערות: המחרוזת השנייה מכילה אחד או יותר
הערות: 'f','r','w','x' כדי לבדוק בהתאמה
הערות: הרשאות קיום, קריאה, כתיבה וביצוע.
הערות: תחת מזהה שורש, הסימון השימושי היחיד הוא 'f', as
הערות: כל השאר יחזרו כ-true.
ערך החזרה: 0 אם הקובץ קיים, ניתן לקריאה, לכתיבה,
ערך החזרה: בר הפעלה, או -1 אם לא.
ראה גם: גבר גישה(2)

I-Function: baud
תיאור : מחזירה את ה-baudrate הנוכחי של קו התקשורת.
תחביר: תן x=baud()
הערות: לא בהכרח תואם את מהירות החיבור של המודם.
ראה גם: $baud().

I-Function: לן
תיאור : מחזירה את אורך המחרוזת.
תחביר : תן x=len($s)
הערות: "" הוא אפס. למחרוזות יש כרגע אורך מקסימלי של
הערות: 1024 תווים. comgt לא מטפל בהצפת מחרוזת
הערות: בכלל.

I-Function: htime
תיאור : מחזירה מאות שניות מאז תחילת הסקריפט.
תחביר : תן x=htime()
הערות: הגדר לערך ספציפי עם hset.
ראה גם: hset.

I-Function: pid
תיאור : מחזיר את מספר מזהה התהליך של התהליך הנוכחי (comgt)
תחביר: תן x=pid()
ראה גם: ppid(), מזלג

I-Function: ppid
תיאור : מחזיר את מספר מזהה התהליך של תהליך האב.
תחביר: תן x=ppid()
הערות: ניתן להשתמש על ידי ילד עם מזלג כדי לזהות הורה
הערות: תהליך.

I-Function: זמן
תיאור : החזרת זמן בשניות מאז 1 בינואר, 00:00:00 1970 GMT.
תחביר : תן x=זמן()
הערות: משמש לחישוב הפרשי זמן.
ראה גם: $time()

I-Function: val
תיאור: מחזירה את ערך המחרוזת.
תחביר : תן x=val($x)
הערות: מחרוזת אינה ביטוי; חייב להכיל רק [0-9]
הערות: תווים. גרסאות עתידיות של comgt יוכלו
הערות: הערכת ביטויים. (אולי) (זה נכתב 6
הערות: לפני שנים.)

I-Function: מילולית
תיאור: מחזירה את הערך של הגדרה מילולית.
תחביר : let x=verbose()
הערות: 0=כבוי, 1=פועל.

מחרוזת פונקציות
S-Function: שם בסיס
תיאור : מחזירה שם בסיס חלק מהנתיב.
תחביר : תן $x=$basename($p)
הערות: $basename("/usr/bin/more")="עוד"
ראה גם: $dirname().

S-פונקציה: baud
תיאור : מחזירה ייצוג מחרוזת של קצב ההעברה הנוכחי.
תחביר : תן $x=$baud()
הערות: מוגדר על ידי "set com"
ראה גם: baud(), set com.

S-פונקציה: cwd
תיאור: מחזיר את שם הנתיב הנוכחי של ספריית העבודה.
תחביר : תן $x=$cwd()
ראה גם: CD.

S-פונקציה: dev
תיאור: מחזירה את שם הנתיב הנוכחי של התקן התקשורת.
תחביר : תן $x=$dev()
הערות: מוגדר על ידי ארגומנט שורת הפקודה "-d" או "פתוח com"
ראה גם: פתח את com.

S-Function: שם שם
תיאור: מחזיר את שם הספרייה חלק מהנתיב.
תחביר : תן $x=$dirname($p)
הערות: $dirname("/usr/bin/more")="/ usr / bin"
ראה גם: $basename().

S-פונקציה: env
תיאור: מחזירה תוכן של משתנה סביבה
תחביר : תן $x=$env("HOME")
הערות: משתנים שאינם קיימים מחזירים מחרוזת ריקה.
ראה גם: putenv.

פונקציית S: hex
תיאור : המרת ערך לייצוג הקסדצימלי
תחביר : תן $x=$hex(x)
הערות: אותיות a-f באותיות קטנות, ללא "0x" קודמת
ראה גם: $hexu(), $oct().

S-פונקציה: hexu
תיאור : המרת ערך לייצוג הקסדצימלי
תחביר : תן $x=$hex(x)
הערות: אותיות A-F באותיות רישיות, ללא "0x" קודמת
ראה גם: $hex(), $oct().

S-פונקציה: hms
תיאור: המרת מספר שניות למחרוזת זמן
תחביר : תן $x=$hms(x)
הערות: הפורמט הוא "HH:MM:SS". שימושי עבור תצוגות כרונומטר
הערות: השתמש עם "זמן()", אל תנסה להגדיל משתנה
הערות: כל שנייה באמצעות "שינה 1". (ראה דוגמה לסקריפט של ISP)
הערות: הפורמט הופך ל-"HHH:MM:SS" לאחר 99 שעות, 59 דקות,
הערות: 59 שניות...
ראה גם: זמן().

פונקציית S: שמאל
תיאור : מחזיר חלק שמאל של מחרוזת
תחביר : תן $x=$left($s,l)
הערות: $s=מחרוזת מקור, l=אורך
הערות: אני חייב להיות קטן מאורך המחרוזת.
ראה גם: $right(), $mid().

פונקציית S: אמצע
תיאור : מחזיר את החלק האמצעי של מחרוזת.
תחביר : תן $x=$mid($s,s,l)
הערות: $s=מחרוזת מקור, s=התחלה, l=אורך
הערות: s חייב להיות קטן מאורך המחרוזת, l יכול להיות
הערות: מספר עצום (9999) כדי להחזיר את הצד הימני של a
הערות: מחרוזת עד הסוף. התו הראשון של מחרוזת הוא
הערות: מיקום 0, לא 1.
ראה גם: $right(), $left().

פונקציית S: אוקטובר
תיאור : ממיר ערך לייצוג אוקטלי.
תחביר : תן $x=$oct(x)
ראה גם: $hex(), $hexu().

פונקציית S: מימין
תיאור : מחזירה חלק ימין של מחרוזת.
תחביר : תן $x=$right($s,l)
הערות: $s=מחרוזת מקור, l=אורך
הערות: אני חייב להיות קטן מאורך המחרוזת.
ראה גם: $left(), $mid().

S-פונקציה: rpipe
תיאור: מחזירה את השורה הראשונה מפקודת מערכת
תחביר : תן $x=$rpipe("/bin/ls |grep myfile")
הערות: לא מאוד שימושי אלא אם כן נעשה בו שימוש עם ראש, זנב, grep,
הערות: וכו'...
ראה גם: מערכת.

S-פונקציה: זמן
תיאור : מחזירה מחרוזת זמן מקומית של 24 תווים
תחביר : תן $x=$time()
ראה גם: זמן().
הערות: השעה היא בפורמט הזה: יום ב' 8 באפריל 14:21:22 1996
012345678901234567890123
1 2

פונקציית S: למטה
תיאור: מחזירה מחרוזת באותיות קטנות.
תחביר : תן $x=$tolower($y)

S-פונקציה: עליון
תיאור : מחזירה מחרוזת רישיות.
תחביר : תן $x=$toupper($y)

מִבְחָן מפעילי
תיאור מפעיל תוצאה לדוגמה
= שווה אם 1+2=3 כן
!= לא שווה אם 1+2!=3 לא
<> לא שווה אם 1+2<>3 לא
> גדול יותר מאשר אם 1+3>3 כן
< פחות מאשר אם 1+3<3 לא
>= גדול יותר או שווה אם 3>=3 כן
<= גדול או שווה אם 2<=3 כן

ניתן להשוות מחרוזות באמצעות אותם אופרטורים.

"aaa" "aaa", "Test" != "test", "One" = "One",
"A" > "a", "Fumble" "Comedic"

הערות ש"הגדר ignorecase on" אינו חל על השוואות מחרוזות.

ביטוי מפעילי
תיאור מפעיל תוצאה לדוגמה
+ הוספה תן a=2+2 4
+ שרשור תן $b="aa"+"bb" "aabb"
- חיסור תן e=2-5 -3
* הכפל תן f=11*2 22
/ חלוקה תן g=34/11 3
& Bit-Wise ותן h=42&7 2
| Bit-Wise או לתת a=42|5 47
^ Bit-Wise XOR תן a=42^7 45

דוגמאות לביטויים מעורבים:

#מחזיר את מספר השניות מאז 00:00:00
תן $t=$time() #צלם תמונת מצב.
let a=(val(mid$($t,11,2))*3600)+(val(mid$($t,14,2))*60)+val(mid$($t,17,2))
#שימו לב לקבוצות הנוספות של סוגריים בגלל הביטוי של comgt
#מעריך מוות מוחי.
#לדוגמה, 5-2+1 אמור לתת לך 4, נכון? ובכן, לפי
#getvalue(), הוא למעשה נותן 2, כי הוא עושה זאת במידת מה
#מימין לשמאל.
#אז כדי להעריך נכון את 5-2+1, השתמש ב-(5-2)+1. אם אתה משתמש
#חישובים פשוטים של שני אלמנטים, אל תדאג בקשר לזה.
מס' 5-2 ייתן לך 3.

#Concatenation (Calls cu)
exec "cu -l "+$dev()+" -s "+$baud()"

#במצב מבחן
if a+c > strlen($c) goto toomuch

#השוואת מחרוזות
תן $t=$mid($time(),11,8)
if $t > "19:59:59" הדפס "מאוחר מדי בשביל זה!\n" יש לעבור ל-toolate
if $t < "08:00:00" הדפס "מוקדם מדי!\n" עבר מוקדם מדי
if $t = "00:00:00" הדפס "אוי אלוהים! זה זמן טווינקי!\n"

ידוע מאפיינים

מנתח getvalue() זה מצחיק אותי אז אני חושב שאשאיר את זה ככה. -
[מוגן בדוא"ל]

הסביבה וריאציות

COMGTPIN - ה-PIN בן 4 הספרות של ה-SIM לשימוש על ידי סקריפט PIN COMGTAPN - ה-APN לכתוב אליו
כרטיס הנתונים, המשמש את סקריפט APN.

מחברים

דניאל.צ'וינארד[מוגן בדוא"ל]> כתב את המקור dcon תוֹעֶלֶת.

פול הארדוויק <[מוגן בדוא"ל]> עדכן אותו עבור המהדרים האחרונים, בתנאי שה-
בפונקציונליות הסקריפט ובדק אותו מול כרטיסי GPRS ו-3G.

מרטין גרגורי <[מוגן בדוא"ל]> כתב את ה-manpage המקורי עבור comgt מ dcon
תיעוד וארוז comgt להפצה.

הִיסטוֹרִיָה
דניאל צ'וינארד כתב את רוב (90%) של dcon עוד ב-1989 כשהתחיל לעשות אפליקציות יוניקס
תמיכה טכנית בעיקר באמצעות מודם למערכות לקוח. נמאס לו להקליד את כל אלה
סיסמאות וקודים מצחיקים לטעינת שיחות בכל פעם שהוא השתמש ב-cu. כמו כן, החברה בה עבד
לצורך צורך במערכת שתרשם זמני שיחות ועלויות משוערות. לכן dcon נולד.
שש או שבע שנים מאוחר יותר (1996) והוא השתמש ב-pppd כדי להתחבר לאתר האינטרנט שלו. הוא היה
מרוצה פחות או יותר צ'אט אבל גילה שאין בו בקרת זרימה ובדיקות תגובה מרובות
מתוך "atdt...". הוא רצה שזה יעשה דברים שונים עבור "ללא ספק", "ללא צליל חיוג" ו
"עסוק". למרות שהוא חשב כך צ'אט כנראה ישתפר מתישהו, כשהוא ימצא
dcon.c באחת מקלטות ה-45M הישנות שלו, הוא ניסה להרכיב אותה בקופסת הלינוקס שלו, והנה
הנה, זה קרה. בסופו של דבר, הוא הוסיף לו כמה דברים (להרוג, להתפצל, להמתין, 1/100 שניות.
פעמים) והשאירו את זה כך.

לפני כמה שנים פול הארדוויק מצא את התוכנית, dcon 0.97, שונה לאחרונה ב-1996.
מטרת תוכנית זו הייתה להריץ סקריפטים שישלטו ביציאות טוריות של לינוקס. ה
היישום היה דומה מאוד למשהו שהוא כתב עבור Windows. בכל מקרה, יותר נכון
מאשר להמציא מחדש, הוא פנה למחבר, דניאל צ'וינארד, וביקש את רשותו לעשות שימוש חוזר
הקוד. לשמחתי הוא נתן רשות ומערכת עזר בסיסית אך שימושית נקראה comgt היה
נוצר. פול לא לוקח קרדיט על המנוע, מלבד הפיכתו לתואם לימינו
מהדרים. זה בעצם dcon ארוז מחדש.

20 אוקטובר, 2006 comgt(1)

השתמש ב-comgt באינטרנט באמצעות שירותי onworks.net